985 lines
28 KiB
C++
985 lines
28 KiB
C++
|
#include "parser.hpp"
|
||
|
|
#include <algorithm>
|
||
|
|
#include <cstring>
|
||
|
|
namespace BoxScript
|
||
|
|
{
|
||
|
|
void IApplicationState::AddThreadOwner()
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
void IApplicationState::RemoveThreadOwner()
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::AddThreadOwner()
|
||
|
|
{
|
||
|
|
this->state->AddThreadOwner();
|
||
|
|
this->threads++;
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::RemoveThreadOwner()
|
||
|
|
{
|
||
|
|
this->state->RemoveThreadOwner();
|
||
|
|
if(this->threads <= 0)
|
||
|
|
{
|
||
|
|
delete this;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ApplicationState::ApplicationState()
|
||
|
|
{
|
||
|
|
this->isRunning=true;
|
||
|
|
this->NoBoxes=0;
|
||
|
|
this->NoExpressions=0;
|
||
|
|
this->NoStreams=0;
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::CreateBox(string text)
|
||
|
|
{
|
||
|
|
int64_t boxId=this->NoBoxes++;
|
||
|
|
if(this->boxes.count(boxId) <= 0)
|
||
|
|
{
|
||
|
|
this->boxes.insert({boxId,{vector<int64_t>(), false}});
|
||
|
|
}
|
||
|
|
for(int i =0;i<text.length();i++)
|
||
|
|
{
|
||
|
|
this->boxes[boxId].first.push_back(text[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return boxId;
|
||
|
|
}
|
||
|
|
|
||
|
|
Expression* ApplicationState::Calln(int64_t e)
|
||
|
|
{
|
||
|
|
if(this->expressions.count(e) > 0)
|
||
|
|
{
|
||
|
|
return expressions[e];
|
||
|
|
}
|
||
|
|
return new ConstantNumber("0");
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::ReadByteFromStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
Stream* strm = GetStream(streamId);
|
||
|
|
return strm->ReadByte();
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::CreateBufferedStream(int64_t existingStreamId)
|
||
|
|
{
|
||
|
|
Stream* strm = GetStream(existingStreamId);
|
||
|
|
return CreateStream(new BufferedStream(strm));
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::e2n(Expression* e)
|
||
|
|
{
|
||
|
|
int64_t eId = this->NoExpressions++;
|
||
|
|
this->expressions.insert({eId,e});
|
||
|
|
return eId;
|
||
|
|
}
|
||
|
|
string ApplicationState::BoxToString(int64_t boxId)
|
||
|
|
{
|
||
|
|
string s ="";
|
||
|
|
if(boxes.count(boxId) == 0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for(int i =0;i<boxes[boxId].first.size();i++)
|
||
|
|
{
|
||
|
|
char c = (char)(boxes[boxId].first[i] % 256);
|
||
|
|
s+= c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::CreateBox(int boxLen)
|
||
|
|
{
|
||
|
|
int64_t i = NoBoxes++;
|
||
|
|
if(this->boxes.count(i) <= 0)
|
||
|
|
{
|
||
|
|
this->boxes.insert({i,{vector<int64_t>(), false}});
|
||
|
|
}
|
||
|
|
this->boxes[i].first.reserve(boxLen);
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
void ApplicationState::AddRuntimeFunction(string str,internal_func func)
|
||
|
|
{
|
||
|
|
if(!HasRuntimeFunction(str))
|
||
|
|
{
|
||
|
|
runtime_funcs.insert({str,func});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ApplicationState::DestroyBox(int64_t boxId)
|
||
|
|
{
|
||
|
|
if(boxes.count(boxId) == 0) return;
|
||
|
|
if(!boxes[boxId].second)
|
||
|
|
{
|
||
|
|
boxes[boxId].first.clear();
|
||
|
|
boxes.erase(boxId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::CreateStream(Stream* strm)
|
||
|
|
{
|
||
|
|
int64_t i = NoStreams++;
|
||
|
|
streams.insert({i,strm});
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::GetBoxValue(int64_t bId,int index)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId) == 0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
if(index>boxes[bId].first.size())
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}else{
|
||
|
|
return boxes[bId].first[index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::SetBoxValue(int64_t bId,int index,int64_t value)
|
||
|
|
{
|
||
|
|
if(value > 2147483647) throw exception();
|
||
|
|
|
||
|
|
if(boxes.count(bId) == 0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw new exception();
|
||
|
|
if(index > boxes[bId].first.size())
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}else{
|
||
|
|
boxes[bId].first[index] = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bool ApplicationState::HasVariable(string name)
|
||
|
|
{
|
||
|
|
return variables.count(name) > 0;
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::GetVariable(string name)
|
||
|
|
{
|
||
|
|
if(variables.count(name) > 0)
|
||
|
|
{
|
||
|
|
return variables[name];
|
||
|
|
}else{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
IApplicationState* ApplicationState::NewScope()
|
||
|
|
{
|
||
|
|
return new SubscopeApplicationState(this);
|
||
|
|
}
|
||
|
|
void ApplicationState::SetVariable(string name,int64_t value)
|
||
|
|
{
|
||
|
|
if(variables.count(name) > 0)
|
||
|
|
{
|
||
|
|
variables[name]=value;
|
||
|
|
}else{
|
||
|
|
variables.insert({name,value});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::ClearBox(int64_t bId)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId) == 0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw exception();
|
||
|
|
boxes[bId].first.clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::AddToBox(int64_t bId,int64_t value)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId) == 0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw exception();
|
||
|
|
boxes[bId].first.push_back(value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::RemoveFromBox(int64_t bId,int64_t value)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId)==0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw exception();
|
||
|
|
vector<int64_t>::iterator itr= find(boxes[bId].first.begin(),boxes[bId].first.end(),value);
|
||
|
|
if(itr < boxes[bId].first.end())
|
||
|
|
{
|
||
|
|
boxes[bId].first.erase(itr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::RemoveAtFromBox(int64_t bId,int index)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId)==0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw exception();
|
||
|
|
vector<int64_t>::iterator itr= boxes[bId].first.begin() + index;
|
||
|
|
if(itr < boxes[bId].first.end())
|
||
|
|
{
|
||
|
|
boxes[bId].first.erase(itr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::InsertToBox(int64_t bId,int index,int64_t value)
|
||
|
|
{
|
||
|
|
if(boxes.count(bId)==0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(boxes[bId].second) throw exception();
|
||
|
|
vector<int64_t>::iterator itr= boxes[bId].first.begin() + index;
|
||
|
|
if(itr != boxes[bId].first.end())
|
||
|
|
{
|
||
|
|
boxes[bId].first.insert(itr,value);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::BoxLength(int64_t boxId)
|
||
|
|
{
|
||
|
|
if(boxes.count(boxId)==0)
|
||
|
|
{
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return boxes[boxId].first.size();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bool ApplicationState::HasRuntimeFunction(string str)
|
||
|
|
{
|
||
|
|
return runtime_funcs.count(str) > 0;
|
||
|
|
}
|
||
|
|
internal_func ApplicationState::GetRuntimeFunction(string str)
|
||
|
|
{
|
||
|
|
return runtime_funcs[str];
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::ExecuteFunction(string str,vector<Expression*> expressions)
|
||
|
|
{
|
||
|
|
if(!HasFunction(str)) return 0;
|
||
|
|
//var func=methods[str]
|
||
|
|
IApplicationState* res = NewScope();
|
||
|
|
res->AddThreadOwner();
|
||
|
|
for(int i = 0;i<min(expressions.size(),methods[str].first.size());i++)
|
||
|
|
{
|
||
|
|
res->SetVariable(methods[str].first[i],expressions[i]->Evaluate(res));
|
||
|
|
}
|
||
|
|
int64_t result= methods[str].second->Evaluate(res);
|
||
|
|
res->RemoveThreadOwner();
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::CreateBoxPermanent(string text)
|
||
|
|
{
|
||
|
|
int64_t boxId=this->NoBoxes++;
|
||
|
|
if(this->boxes.count(boxId) <= 0)
|
||
|
|
{
|
||
|
|
this->boxes.insert({boxId,{vector<int64_t>(), true}});
|
||
|
|
}
|
||
|
|
for(int i =0;i<text.length();i++)
|
||
|
|
{
|
||
|
|
this->boxes[boxId].first.push_back(text[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return boxId;
|
||
|
|
}
|
||
|
|
bool ApplicationState::HasFunction(string str)
|
||
|
|
{
|
||
|
|
return methods.count(str) > 0;
|
||
|
|
}
|
||
|
|
void ApplicationState::AddFunction(string str,vector<string> args,Expression* exp)
|
||
|
|
{
|
||
|
|
if(!HasFunction(str))
|
||
|
|
{
|
||
|
|
methods.insert({str,{args,exp}});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void ApplicationState::CopyStream(int64_t src,int64_t dest)
|
||
|
|
{
|
||
|
|
if(streams.count(src) == 0 || streams.count(dest) == 0) return;
|
||
|
|
GetStream(src)->CopyTo(GetStream(dest));
|
||
|
|
}
|
||
|
|
Stream* ApplicationState::GetStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) throw exception();
|
||
|
|
return streams[streamId];
|
||
|
|
}
|
||
|
|
void ApplicationState::CloseStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
|
||
|
|
if(streams.count(streamId)==0) throw exception();
|
||
|
|
streams[streamId]->Close();
|
||
|
|
delete streams[streamId];
|
||
|
|
streams.erase(streamId);
|
||
|
|
|
||
|
|
}
|
||
|
|
void ApplicationState::WriteToStream(int64_t streamId,int64_t boxId,int64_t offset,int64_t len)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return;
|
||
|
|
Stream* strm=GetStream(streamId);
|
||
|
|
if(!strm->CanWrite())return;
|
||
|
|
size_t len2=boxes[boxId].first.size();
|
||
|
|
len2-=offset;
|
||
|
|
int64_t len3=min(len,(int64_t)len2);
|
||
|
|
uint8_t data[len3];
|
||
|
|
for(int64_t i = 0;i<len3;i++)
|
||
|
|
{
|
||
|
|
uint8_t byte=(uint8_t)boxes[boxId].first[i+offset];
|
||
|
|
data[i] = byte;
|
||
|
|
}
|
||
|
|
strm->Write(data,(size_t)len3);
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::ReadFromStream(int64_t streamId,int64_t boxId,int64_t offset,int64_t len)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return 0;
|
||
|
|
Stream* strm=GetStream(streamId);
|
||
|
|
if(boxes[boxId].second || !strm->CanRead()) return 0;
|
||
|
|
size_t len2=boxes[boxId].first.size();
|
||
|
|
len2-=offset;
|
||
|
|
int64_t len3=min(len,(int64_t)len2);
|
||
|
|
uint8_t data[len3];
|
||
|
|
len3=strm->Read(data,len3);
|
||
|
|
for(int64_t i = 0;i<len3;i++)
|
||
|
|
{
|
||
|
|
boxes[boxId].first[i+offset]=data[i];
|
||
|
|
}
|
||
|
|
return len3;
|
||
|
|
}
|
||
|
|
void ApplicationState::SetStreamPosition(int64_t streamId,int64_t streamPos)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return;
|
||
|
|
Stream* strm=GetStream(streamId);
|
||
|
|
if(!strm->CanSeek()) return;
|
||
|
|
strm->SetPosition(streamPos);
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::GetStreamLength(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return 0;
|
||
|
|
Stream* strm=GetStream(streamId);
|
||
|
|
return strm->GetLength();
|
||
|
|
}
|
||
|
|
int64_t ApplicationState::GetStreamPosition(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return 0;
|
||
|
|
Stream* strm=GetStream(streamId);
|
||
|
|
if(!strm->CanSeek()) return 0;
|
||
|
|
return strm->GetPosition();
|
||
|
|
}
|
||
|
|
bool ApplicationState::CanRead(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return false;
|
||
|
|
return GetStream(streamId)->CanRead();
|
||
|
|
}
|
||
|
|
bool ApplicationState::CanWrite(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return false;
|
||
|
|
return GetStream(streamId)->CanWrite();
|
||
|
|
}
|
||
|
|
bool ApplicationState::CanSeek(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return false;
|
||
|
|
return GetStream(streamId)->CanSeek();
|
||
|
|
}
|
||
|
|
void ApplicationState::FlushStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
if(streams.count(streamId) == 0) return;
|
||
|
|
GetStream(streamId)->Flush();
|
||
|
|
}
|
||
|
|
|
||
|
|
#pragma region SubscopeApplicationState
|
||
|
|
SubscopeApplicationState::SubscopeApplicationState(IApplicationState* _state)
|
||
|
|
{
|
||
|
|
this->threads=0;
|
||
|
|
this->state=_state;
|
||
|
|
}
|
||
|
|
internal_func SubscopeApplicationState::GetRuntimeFunction(string str)
|
||
|
|
{
|
||
|
|
return this->state->GetRuntimeFunction(str);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::FlushStream(int64_t stream)
|
||
|
|
{
|
||
|
|
this->state->FlushStream(stream);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::DestroyBox(int64_t id)
|
||
|
|
{
|
||
|
|
this->state->DestroyBox(id);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::e2n(Expression* e)
|
||
|
|
{
|
||
|
|
return this->state->e2n(e);
|
||
|
|
}
|
||
|
|
Expression* SubscopeApplicationState::Calln(int64_t e)
|
||
|
|
{
|
||
|
|
return this->state->Calln(e);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::CreateStream(Stream* strm)
|
||
|
|
{
|
||
|
|
return this->state->CreateStream(strm);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::CopyStream(int64_t strmSrc,int64_t strmDest)
|
||
|
|
{
|
||
|
|
this->state->CopyStream(strmSrc,strmDest);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::CloseStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
this->state->CloseStream(streamId);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::WriteToStream(int64_t streamId,int64_t boxId,int64_t offset,int64_t len)
|
||
|
|
{
|
||
|
|
this->state->WriteToStream(streamId,boxId,offset,len);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::ReadFromStream(int64_t streamId,int64_t boxId,int64_t offset,int64_t len)
|
||
|
|
{
|
||
|
|
return this->state->ReadFromStream(streamId,boxId,offset,len);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::SetStreamPosition(int64_t streamId,int64_t streamPos)
|
||
|
|
{
|
||
|
|
this->state->SetStreamPosition(streamId,streamPos);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::GetStreamPosition(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->GetStreamPosition(streamId);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::GetStreamLength(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->GetStreamLength(streamId);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::CanRead(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->CanRead(streamId);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::CanWrite(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->CanWrite(streamId);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::CanSeek(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->CanSeek(streamId);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::ExecuteFunction(string str,vector<Expression*> expressions)
|
||
|
|
{
|
||
|
|
return this->state->ExecuteFunction(str,expressions);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::HasRuntimeFunction(string str)
|
||
|
|
{
|
||
|
|
return this->state->HasRuntimeFunction(str);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::HasFunction(string str)
|
||
|
|
{
|
||
|
|
return this->state->HasFunction(str);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::AddFunction(string str,vector<string> args,Expression* exp)
|
||
|
|
{
|
||
|
|
this->state->AddFunction(str,args,exp);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::AddRuntimeFunction(string str,internal_func func)
|
||
|
|
{
|
||
|
|
this->state->AddRuntimeFunction(str,func);
|
||
|
|
}
|
||
|
|
string SubscopeApplicationState::BoxToString(int64_t boxId)
|
||
|
|
{
|
||
|
|
return this->state->BoxToString(boxId);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::ClearBox(int64_t bId)
|
||
|
|
{
|
||
|
|
this->state->ClearBox(bId);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::ReadByteFromStream(int64_t streamId)
|
||
|
|
{
|
||
|
|
return this->state->ReadByteFromStream(streamId);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::CreateBufferedStream(int64_t existingStreamId)
|
||
|
|
{
|
||
|
|
return this->state->CreateBufferedStream(existingStreamId);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::AddToBox(int64_t bId,int64_t value)
|
||
|
|
{
|
||
|
|
this->state->AddToBox(bId,value);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::RemoveFromBox(int64_t bId,int64_t value)
|
||
|
|
{
|
||
|
|
this->state->RemoveFromBox(bId,value);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::RemoveAtFromBox(int64_t bId,int index)
|
||
|
|
{
|
||
|
|
this->state->RemoveAtFromBox(bId,index);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::InsertToBox(int64_t bId,int index,int64_t value)
|
||
|
|
{
|
||
|
|
this->state->InsertToBox(bId,index,value);
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::SetBoxValue(int64_t bId,int index,int64_t value)
|
||
|
|
{
|
||
|
|
this->state->SetBoxValue(bId,index,value);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::BoxLength(int64_t boxId)
|
||
|
|
{
|
||
|
|
return this->state->BoxLength(boxId);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::CreateBox(int len)
|
||
|
|
{
|
||
|
|
return this->state->CreateBox(len);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::CreateBox(string text)
|
||
|
|
{
|
||
|
|
return this->state->CreateBox(text);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::CreateBoxPermanent(string text)
|
||
|
|
{
|
||
|
|
return this->state->CreateBoxPermanent(text);
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::GetBoxValue(int64_t bId, int index)
|
||
|
|
{
|
||
|
|
return this->state->GetBoxValue(bId,index);
|
||
|
|
}
|
||
|
|
bool SubscopeApplicationState::HasVariable(string name)
|
||
|
|
{
|
||
|
|
return variables.count(name) > 0 || (name.substr(0,4) != "cur." && this->state->HasVariable(name));
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::SetVariable(string name,int64_t value)
|
||
|
|
{
|
||
|
|
if(name.substr(0,4) != "cur." && state->HasVariable(name))
|
||
|
|
{
|
||
|
|
this->state->SetVariable(name,value);
|
||
|
|
}else{
|
||
|
|
if(this->variables.count(name) > 0)
|
||
|
|
{
|
||
|
|
variables[name]=value;
|
||
|
|
}else{
|
||
|
|
variables.insert({name,value});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int64_t SubscopeApplicationState::GetVariable(string name)
|
||
|
|
{
|
||
|
|
if(name.substr(0,4) != "cur." && state->HasVariable(name))
|
||
|
|
{
|
||
|
|
return this->state->GetVariable(name);
|
||
|
|
}else{
|
||
|
|
if(this->variables.count(name) > 0) return this->variables[name];
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
IApplicationState* SubscopeApplicationState::NewScope()
|
||
|
|
{
|
||
|
|
return new SubscopeApplicationState(this);
|
||
|
|
}
|
||
|
|
#pragma endregion
|
||
|
|
|
||
|
|
|
||
|
|
void Stream::CopyTo(Stream* strm)
|
||
|
|
{
|
||
|
|
uint8_t buffer[4096];
|
||
|
|
size_t read;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
read = this->Read(buffer,4096);
|
||
|
|
strm->Write(buffer,read);
|
||
|
|
} while (read != 0);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
ExpressionStream::ExpressionStream(IApplicationState* state,vector<Expression*> expressions)
|
||
|
|
{
|
||
|
|
this->st = state;
|
||
|
|
this->exp = exp;
|
||
|
|
|
||
|
|
}
|
||
|
|
void ExpressionStream::Write(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
int64_t box = st->CreateBox((int64_t)len);
|
||
|
|
IApplicationState* newSc = st->NewScope();
|
||
|
|
newSc->AddThreadOwner();
|
||
|
|
newSc->SetVariable("stream_count_value",len);
|
||
|
|
newSc->SetVariable("stream_buffer",box);
|
||
|
|
|
||
|
|
for(size_t i = 0;i<len;i++)
|
||
|
|
{
|
||
|
|
st->AddToBox(box,data[i]);
|
||
|
|
}
|
||
|
|
exp[1]->Evaluate(newSc);
|
||
|
|
newSc->DestroyBox(box);
|
||
|
|
newSc->RemoveThreadOwner();
|
||
|
|
}
|
||
|
|
size_t ExpressionStream::Read(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
int64_t box = st->CreateBox((int64_t)len);
|
||
|
|
IApplicationState* newSc = st->NewScope();
|
||
|
|
newSc->AddThreadOwner();
|
||
|
|
newSc->SetVariable("stream_count_value",len);
|
||
|
|
newSc->SetVariable("stream_buffer",box);
|
||
|
|
size_t read = (size_t)exp[0]->Evaluate(newSc);
|
||
|
|
for(size_t i = 0;i<min(read,len);i++)
|
||
|
|
{
|
||
|
|
uint8_t v = (uint8_t)st->GetBoxValue(box,(int)i);
|
||
|
|
data[i]=v;
|
||
|
|
}
|
||
|
|
newSc->DestroyBox(box);
|
||
|
|
newSc->RemoveThreadOwner();
|
||
|
|
return min(read,len);
|
||
|
|
}
|
||
|
|
int64_t ExpressionStream::GetPosition()
|
||
|
|
{
|
||
|
|
//3
|
||
|
|
return exp[3]->Evaluate(st);
|
||
|
|
}
|
||
|
|
int64_t ExpressionStream::GetLength()
|
||
|
|
{
|
||
|
|
//4
|
||
|
|
return exp[4]->Evaluate(st) > 0;
|
||
|
|
}
|
||
|
|
void ExpressionStream::SetPosition(int64_t pos)
|
||
|
|
{
|
||
|
|
//2
|
||
|
|
IApplicationState* newSc = st->NewScope();
|
||
|
|
newSc->AddThreadOwner();
|
||
|
|
newSc->SetVariable("stream_length_value",pos);
|
||
|
|
exp[2]->Evaluate(newSc);
|
||
|
|
newSc->RemoveThreadOwner();
|
||
|
|
}
|
||
|
|
void ExpressionStream::Flush()
|
||
|
|
{
|
||
|
|
//8
|
||
|
|
exp[8]->Evaluate(st);
|
||
|
|
}
|
||
|
|
void ExpressionStream::Close()
|
||
|
|
{
|
||
|
|
//9
|
||
|
|
exp[9]->Evaluate(st);
|
||
|
|
}
|
||
|
|
bool ExpressionStream::CanRead()
|
||
|
|
{
|
||
|
|
//5
|
||
|
|
return exp[5]->Evaluate(st) > 0;
|
||
|
|
}
|
||
|
|
bool ExpressionStream::CanWrite()
|
||
|
|
{
|
||
|
|
//6
|
||
|
|
return exp[6]->Evaluate(st) > 0;
|
||
|
|
}
|
||
|
|
bool ExpressionStream::CanSeek()
|
||
|
|
{
|
||
|
|
//7
|
||
|
|
return exp[7]->Evaluate(st) > 0;
|
||
|
|
}
|
||
|
|
FileStream::FileStream(FILE* fs,bool canRead,bool canWrite,bool canSeek,bool ownFile)
|
||
|
|
{
|
||
|
|
this->f=fs;
|
||
|
|
this->cr = canRead;
|
||
|
|
this->cw = canWrite;
|
||
|
|
this->cs = canSeek;
|
||
|
|
this->own=ownFile;
|
||
|
|
}
|
||
|
|
bool FileStream::CanSeek()
|
||
|
|
{
|
||
|
|
return this->cs;
|
||
|
|
}
|
||
|
|
bool FileStream::CanRead()
|
||
|
|
{
|
||
|
|
return this->cr;
|
||
|
|
}
|
||
|
|
bool FileStream::CanWrite()
|
||
|
|
{
|
||
|
|
return this->cw;
|
||
|
|
}
|
||
|
|
void FileStream::Write(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
if(!cw) return;
|
||
|
|
fwrite(data,1,len,f);
|
||
|
|
}
|
||
|
|
size_t FileStream::Read(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
if(!cr) return 0;
|
||
|
|
return fread(data,1,len,f);
|
||
|
|
}
|
||
|
|
void FileStream::Flush()
|
||
|
|
{
|
||
|
|
fflush(f);
|
||
|
|
}
|
||
|
|
void FileStream::Close()
|
||
|
|
{
|
||
|
|
if(own)
|
||
|
|
fclose(f);
|
||
|
|
}
|
||
|
|
int64_t FileStream::GetPosition()
|
||
|
|
{
|
||
|
|
if(!cs) return 0;
|
||
|
|
return (int64_t)ftello(f);
|
||
|
|
}
|
||
|
|
int64_t FileStream::GetLength()
|
||
|
|
{
|
||
|
|
if(!cs) return 0;
|
||
|
|
fpos_t pos;
|
||
|
|
|
||
|
|
|
||
|
|
fgetpos(f,&pos);
|
||
|
|
fseeko(f,0,SEEK_END);
|
||
|
|
int64_t len= (int64_t)ftello(f);
|
||
|
|
fsetpos(f,&pos);
|
||
|
|
return len;
|
||
|
|
}
|
||
|
|
void FileStream::SetPosition(int64_t pos)
|
||
|
|
{
|
||
|
|
if(!cs) return;
|
||
|
|
fseeko(f,(off_t)pos,SEEK_SET);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Parse(ListNode* node,vector<Lexer::LexToken> tokens)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
ParseNode(node,tokens,&i,true);
|
||
|
|
}
|
||
|
|
ListNode* Parse(vector<Lexer::LexToken> tokens)
|
||
|
|
{
|
||
|
|
ListNode* node = new ListNode();
|
||
|
|
Parse(node,tokens);
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
void ParseNode(ListNode* node,vector<Lexer::LexToken> tokens,int* i)
|
||
|
|
{
|
||
|
|
ParseNode(node,tokens,i,false);
|
||
|
|
}
|
||
|
|
void ParseNode(ListNode* node,vector<Lexer::LexToken> tokens,int* i,bool root)
|
||
|
|
{
|
||
|
|
node->root = root;
|
||
|
|
while(*i < tokens.size() && tokens[*i].type != Lexer::RBRACE)
|
||
|
|
{
|
||
|
|
if(tokens[*i].type == Lexer::SEMI) (*i)++;
|
||
|
|
if(*i+2 < tokens.size() && tokens[*i+1].type == Lexer::EQUALS )
|
||
|
|
{
|
||
|
|
string varname = tokens[*i].text;
|
||
|
|
*i=*i+2;
|
||
|
|
node->nodes.push_back(new SetVariableNode(ParseExpression(tokens,i),varname));
|
||
|
|
if(!root && *i<tokens.size() && tokens[*i].type == Lexer::RBRACE) break;
|
||
|
|
(*i)++;
|
||
|
|
}
|
||
|
|
else if(*i+1 < tokens.size() && tokens[*i+1].type == Lexer::LPAREN)
|
||
|
|
{
|
||
|
|
node->nodes.push_back(ParseExpression(tokens,i));
|
||
|
|
if(!root && *i<tokens.size() && tokens[*i].type == Lexer::RBRACE) break;
|
||
|
|
(*i)++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
node->nodes.push_back(ParseExpression(tokens,i));
|
||
|
|
if(!root && *i<tokens.size() && tokens[*i].type == Lexer::RBRACE) break;
|
||
|
|
(*i)++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Expression* ParseExpression(vector<Lexer::LexToken> tokens,int* i)
|
||
|
|
{
|
||
|
|
Expression* res = ParseTerm(tokens,i);
|
||
|
|
while(*i < tokens.size() && (tokens[*i].type == Lexer::PLUS||tokens[*i].type == Lexer::MINUS))
|
||
|
|
{
|
||
|
|
if(*i < tokens.size() && tokens[*i].type == Lexer::PLUS)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
res = (Expression*)new AddNode(res,ParseTerm(tokens,i));
|
||
|
|
}
|
||
|
|
if(*i < tokens.size() && tokens[*i].type == Lexer::MINUS)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
res = (Expression*)new MinusNode(res,ParseTerm(tokens,i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
Expression* ParseTerm(vector<Lexer::LexToken> tokens,int* i)
|
||
|
|
{
|
||
|
|
Expression* res = ParseFactor(tokens,i);
|
||
|
|
while(*i < tokens.size() && (tokens[*i].type == Lexer::MULTIPLY||tokens[*i].type == Lexer::DIVIDE ||tokens[*i].type == Lexer::MOD))
|
||
|
|
{
|
||
|
|
if(*i < tokens.size() && tokens[*i].type == Lexer::MULTIPLY)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
res = (Expression*)new MultiplyNode(res,ParseFactor(tokens,i));
|
||
|
|
}
|
||
|
|
if(*i < tokens.size() && tokens[*i].type == Lexer::DIVIDE)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
res = (Expression*)new DivideNode(res,ParseFactor(tokens,i));
|
||
|
|
}
|
||
|
|
if(*i < tokens.size() && tokens[*i].type == Lexer::MOD)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
res = (Expression*)new ModulusNode(res,ParseFactor(tokens,i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
Expression* ParseFactor(vector<Lexer::LexToken> tokens,int* i)
|
||
|
|
{
|
||
|
|
if(*i>=tokens.size()) throw exception();
|
||
|
|
Lexer::LexToken token = tokens[*i];
|
||
|
|
if(token.type == Lexer::LPAREN)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
Expression* res = ParseExpression(tokens,i);
|
||
|
|
if(*i>=tokens.size()) throw exception();
|
||
|
|
if(tokens[*i].type != Lexer::RPAREN) throw exception();
|
||
|
|
(*i)++;
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
if(token.type == Lexer::LBRACE)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
ListNode* res = new ListNode();
|
||
|
|
ParseNode(res,tokens,i,false);
|
||
|
|
if(*i>=tokens.size()) throw exception();
|
||
|
|
if(tokens[*i].type != Lexer::RBRACE) throw exception();
|
||
|
|
(*i)++;
|
||
|
|
return (Expression*)res;
|
||
|
|
}
|
||
|
|
if(token.type == Lexer::IDENTIFER)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
if(*i<tokens.size() && tokens[*i].type == Lexer::LPAREN)
|
||
|
|
{
|
||
|
|
vector<Expression*> funcArgs;
|
||
|
|
(*i)++;
|
||
|
|
while(*i<tokens.size() && tokens[*i].type != Lexer::RPAREN)
|
||
|
|
{
|
||
|
|
if(tokens[*i].type == Lexer::COMMA) (*i)++;
|
||
|
|
funcArgs.push_back(ParseExpression(tokens,i));
|
||
|
|
}
|
||
|
|
(*i)++;
|
||
|
|
return (Expression*)new FunctionCallNode(token.text,funcArgs);
|
||
|
|
}else{
|
||
|
|
return (Expression*)new VariableGetValueNode(token.text);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(token.type == Lexer::STRING)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
return (Expression*)new StringNode(token.text);
|
||
|
|
}
|
||
|
|
if(token.type == Lexer::NUMBER)
|
||
|
|
{
|
||
|
|
(*i)++;
|
||
|
|
return (Expression*)new ConstantNumber(token.text);
|
||
|
|
}
|
||
|
|
throw exception();
|
||
|
|
}
|
||
|
|
void ApplicationState::StopRunning()
|
||
|
|
{
|
||
|
|
std::vector<Expression*> exp;
|
||
|
|
this->isRunning=(bool)this->ExecuteFunction("stopinterrupt",exp);
|
||
|
|
}
|
||
|
|
void ApplicationState::ExitIfNotRunning()
|
||
|
|
{
|
||
|
|
if(!isRunning)
|
||
|
|
{
|
||
|
|
exit(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::StopRunning()
|
||
|
|
{
|
||
|
|
this->state->StopRunning();
|
||
|
|
}
|
||
|
|
void SubscopeApplicationState::ExitIfNotRunning()
|
||
|
|
{
|
||
|
|
this->state->ExitIfNotRunning();
|
||
|
|
}
|
||
|
|
|
||
|
|
#pragma region "BufferedStream"
|
||
|
|
BufferedStream::BufferedStream(Stream* parent)
|
||
|
|
{
|
||
|
|
|
||
|
|
this->strm = parent;
|
||
|
|
|
||
|
|
}
|
||
|
|
int64_t Stream::ReadByte()
|
||
|
|
{
|
||
|
|
uint8_t buffer[1];
|
||
|
|
return this->Read(buffer,1) > 0 ? buffer[0] : -1;
|
||
|
|
}
|
||
|
|
int64_t BufferedStream::ReadByte()
|
||
|
|
{
|
||
|
|
if(pos<min((int)this->readIn,4096))
|
||
|
|
{
|
||
|
|
return (int64_t)this->buffer[this->pos];
|
||
|
|
}else{
|
||
|
|
this->readIn=this->strm->Read(this->buffer,4096);
|
||
|
|
this->pos = 0;
|
||
|
|
|
||
|
|
if(this->readIn > 0)
|
||
|
|
{
|
||
|
|
return this->buffer[this->pos++];
|
||
|
|
}else{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void BufferedStream::Write(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
this->strm->Write(data,len);
|
||
|
|
}
|
||
|
|
size_t BufferedStream::Read(uint8_t* data,size_t len)
|
||
|
|
{
|
||
|
|
if(this->pos<min((int)this->readIn,4096) && this->pos > 0)
|
||
|
|
{
|
||
|
|
int _len=min((int)this->readIn-this->pos,(int)len);
|
||
|
|
memcpy(data,this->buffer + this->pos,_len);
|
||
|
|
this->pos+=_len;
|
||
|
|
return _len;
|
||
|
|
}else{
|
||
|
|
return this->strm->Read(data,len);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int64_t BufferedStream::GetPosition()
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
int64_t BufferedStream::GetLength()
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
void BufferedStream::SetPosition(int64_t pos)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
void BufferedStream::Flush()
|
||
|
|
{
|
||
|
|
this->strm->Flush();
|
||
|
|
}
|
||
|
|
void BufferedStream::Close()
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
bool BufferedStream::CanRead()
|
||
|
|
{
|
||
|
|
return this->strm->CanRead();
|
||
|
|
}
|
||
|
|
bool BufferedStream::CanWrite()
|
||
|
|
{
|
||
|
|
return this->strm->CanWrite();
|
||
|
|
}
|
||
|
|
bool BufferedStream::CanSeek()
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
#pragma endregion
|
||
|
|
};
|