void CompilationEngine::compileParameterList()
{
/* ((type varName)(',' type varName)*)? */
tagNonTerminal("parameterList");
if (jt.tokenType() != TokenType::kSYMBOL) {
readType();
nextToken();
readIdentifier();
nextToken();
while (jt.tokenType() == TokenType::kSYMBOL && jt.symbol() == ',') {
readSymbol(',');
nextToken();
readType();
nextToken();
readIdentifier();
nextToken();
}
}
untagNonTerminal("parameterList");
}
void Vfile::read_dynamics(ifstream &v) {
short len;
short GroupID;
int frame;
int prev_frame = -1;
while(1) {
readType(v, &len);
if (v.eof()) { cout << "JUST KIDDING: Actually end of v file" << endl; return; }
if (VDEBUG) cout << "length of dynamic data record: " << len << endl;
readType(v, &GroupID);
if (GroupID != bodies.GroupID) {
cout << "Ignoring data from different GroupID" << endl;
v.seekg(len - 2, std::ios_base::cur);
} else {
readType(v, &frame);
if (prev_frame != -1 && prev_frame+1 != frame) {
cout << "Frame jump : " << prev_frame
<< "to " << frame << endl;
}
prev_frame = frame;
vector< double > d(bodies.DOFlabels.size(), 0.0);
for (unsigned int i = 0; i < d.size(); ++i) {
readType(v, &(d[i]));
if (VDEBUG) cout << d[i] << '\t';
}
if (VDEBUG) cout << endl;
frames.push_back(d);
}
}
}
void CompilationEngine::compileClassVarDec()
{
/* ('static' | 'field') type varName (',' varName)* ';' */
tagNonTerminal("classVarDec");
if (jt.keyword() == Keyword::kFIELD)
readKeyword("field", Keyword::kFIELD);
else
readKeyword("static", Keyword::kSTATIC);
nextToken();
readType();
nextToken();
readIdentifier();
nextToken();
while (jt.tokenType() == TokenType::kSYMBOL && jt.symbol() == ',') {
readSymbol(',');
nextToken();
readIdentifier();
nextToken();
}
readSymbol(';');
untagNonTerminal("classVarDec");
nextToken();
}
void CompilationEngine::compileSubroutine()
{
/* ('constructor' | 'function' | 'method')
('void' | type) subroutineName '(' parameterList ')'
subroutineBody */
tagNonTerminal("subroutineDec");
if (jt.keyword() == Keyword::kCONSTRUCTOR)
readKeyword("constructor", Keyword::kCONSTRUCTOR);
else if (jt.keyword() == Keyword::kFUNCTION)
readKeyword("function", Keyword::kFUNCTION);
else
readKeyword("method", Keyword::kMETHOD);
nextToken();
if (jt.tokenType() == TokenType::kKEYWORD && jt.keyword() == Keyword::kVOID)
readKeyword("void", Keyword::kVOID);
else
readType();
nextToken();
readIdentifier();
nextToken();
readSymbol('(');
nextToken();
compileParameterList();
readSymbol(')');
nextToken();
compileSubroutineBody();
untagNonTerminal("subroutineDec");
}
void TypeTable::loadFromFile(const QString& fileName)
{
TRACE("reading file " + fileName);
KConfig confFile(fileName, KConfig::SimpleConfig);
/*
* Read library name and properties.
*/
KConfigGroup cf = confFile.group(TypeTableGroup);
m_displayName = cf.readEntry(LibDisplayName);
if (m_displayName.isEmpty()) {
// use file name instead
QFileInfo fi(fileName);
m_displayName = fi.completeBaseName();
}
m_shlibNameRE = QRegExp(cf.readEntry(ShlibRE));
m_enabledBuiltins = cf.readEntry(EnableBuiltin, QStringList());
QString printQString = cf.readEntry(PrintQStringCmd);
m_printQStringDataCmd = printQString.toAscii();
/*
* Get the types. We search for entries of kind Types1, Types2, etc.
* because a single entry Types could get rather long for large
* libraries.
*/
QString typesEntry;
for (int i = 1; ; i++) {
// next bunch of types
KConfigGroup cf = confFile.group(TypeTableGroup);
typesEntry.sprintf(TypesEntryFmt, i);
if (!cf.hasKey(typesEntry))
break;
QStringList typeNames = cf.readEntry(typesEntry, QStringList());
// now read them
QString alias;
for (QStringList::iterator it = typeNames.begin(); it != typeNames.end(); ++it)
{
KConfigGroup cf = confFile.group(*it);
// check if this is an alias
alias = cf.readEntry(AliasEntry);
if (alias.isEmpty()) {
readType(cf, *it);
} else {
// look up the alias type and insert it
TypeInfoMap::iterator i = m_typeDict.find(alias);
if (i == m_typeDict.end()) {
TRACE(*it + ": alias " + alias + " not found");
} else {
m_aliasDict.insert(std::make_pair(*it, &i->second));
TRACE(*it + ": alias " + alias);
}
}
}
} // for all Types%d
}
void Rules::readFromCfg(const KConfigGroup& cfg)
{
description = cfg.readEntry("Description");
if (description.isEmpty()) // capitalized first, lowercase for backwards compatibility
description = cfg.readEntry("description");
READ_MATCH_STRING(wmclass, .toLower().toLatin1());
wmclasscomplete = cfg.readEntry("wmclasscomplete" , false);
READ_MATCH_STRING(windowrole, .toLower().toLatin1());
READ_MATCH_STRING(title,);
READ_MATCH_STRING(clientmachine, .toLower().toLatin1());
types = NET::WindowTypeMask(cfg.readEntry<uint>("types", NET::AllTypesMask));
READ_FORCE_RULE2(placement, QString(), Placement::policyFromString, false);
READ_SET_RULE_DEF(position, , invalidPoint);
READ_SET_RULE(size, , QSize());
if (size.isEmpty() && sizerule != (SetRule)Remember)
sizerule = UnusedSetRule;
READ_FORCE_RULE(minsize, , QSize());
if (!minsize.isValid())
minsize = QSize(1, 1);
READ_FORCE_RULE(maxsize, , QSize());
if (maxsize.isEmpty())
maxsize = QSize(32767, 32767);
READ_FORCE_RULE(opacityactive, , 0);
if (opacityactive < 0 || opacityactive > 100)
opacityactive = 100;
READ_FORCE_RULE(opacityinactive, , 0);
if (opacityinactive < 0 || opacityinactive > 100)
opacityinactive = 100;
READ_SET_RULE(ignoregeometry, , false);
READ_SET_RULE(desktop, , 0);
READ_SET_RULE(screen, , 0);
READ_SET_RULE(activity, , QString());
type = readType(cfg, QStringLiteral("type"));
typerule = type != NET::Unknown ? readForceRule(cfg, QStringLiteral("typerule")) : UnusedForceRule;
READ_SET_RULE(maximizevert, , false);
READ_SET_RULE(maximizehoriz, , false);
READ_SET_RULE(minimize, , false);
READ_SET_RULE(shade, , false);
READ_SET_RULE(skiptaskbar, , false);
READ_SET_RULE(skippager, , false);
READ_SET_RULE(skipswitcher, , false);
READ_SET_RULE(above, , false);
READ_SET_RULE(below, , false);
READ_SET_RULE(fullscreen, , false);
READ_SET_RULE(noborder, , false);
decocolor = readDecoColor(cfg);
decocolorrule = decocolor.isEmpty() ? UnusedForceRule : readForceRule(cfg, QStringLiteral("decocolorrule"));
READ_FORCE_RULE(blockcompositing, , false);
READ_FORCE_RULE(fsplevel, limit0to4, 0); // fsp is 0-4
READ_FORCE_RULE(fpplevel, limit0to4, 0); // fpp is 0-4
READ_FORCE_RULE(acceptfocus, , false);
READ_FORCE_RULE(closeable, , false);
READ_FORCE_RULE(autogroup, , false);
READ_FORCE_RULE(autogroupfg, , true);
READ_FORCE_RULE(autogroupid, , QString());
READ_FORCE_RULE(strictgeometry, , false);
READ_SET_RULE(shortcut, , QString());
READ_FORCE_RULE(disableglobalshortcuts, , false);
}
NLPacket::NLPacket(Packet&& packet) :
Packet(std::move(packet))
{
readType();
readVersion();
readSourceID();
adjustPayloadStartAndCapacity(NLPacket::localHeaderSize(_type), _payloadSize > 0);
}
static void readAbsFun(FILE *f, AbsFun fun) {
fun->name = readCId(f);
fun->ty = readType(f);
fun->arrity = readInt(f);
if (readTag(f) != 0)
fun->equs = readEquations(f);
else
fun->equs = NULL;
}
void Vfile::read_header(ifstream &v) {
char buffer[2];
short version;
v.read(buffer, 2);
if (v.fail()) cout << "ERROR: header read failed" << endl;
if (buffer[0]!='V') { cout << "ERROR: expected V, got " << buffer[0] << endl; read_ok = false; }
if (buffer[1]!='#') { cout << "ERROR: expected #, got " << buffer[1] << endl; read_ok = false; }
readType(v, &version);
cout << "Got version: " << version << endl;
}
Packet::Packet(std::unique_ptr<char[]> data, qint64 size, const HifiSockAddr& senderSockAddr) :
_packetSize(size),
_packet(std::move(data)),
_senderSockAddr(senderSockAddr)
{
_type = readType();
_version = readVersion();
_payloadCapacity = _packetSize - localHeaderSize(_type);
_payloadSize = _payloadCapacity;
_payloadStart = _packet.get() + (_packetSize - _payloadCapacity);
}
// ===================================================
// Methods
// ===================================================
void
BCInterfaceData0D::readBC( const std::string& fileName, const std::string& dataSection, const std::string& name )
{
// Call to the base class
dataContainer_Type::readBC( fileName, dataSection, name );
// Read 0D data
GetPot dataFile( fileName );
readFlag( dataFile, ( dataSection + name + "/flag" ).c_str() );
readType( dataFile, ( dataSection + name + "/type0D" ).c_str() );
}
NLPacket::NLPacket(std::unique_ptr<char[]> data, qint64 size, const HifiSockAddr& senderSockAddr) :
Packet(std::move(data), size, senderSockAddr)
{
// sanity check before we decrease the payloadSize with the payloadCapacity
Q_ASSERT(_payloadSize == _payloadCapacity);
readType();
readVersion();
readSourceID();
adjustPayloadStartAndCapacity(NLPacket::localHeaderSize(_type), _payloadSize > 0);
}
void Client::receiveData(){
if(type == -1)
type = readType();
switch(type){
case Constants::STRING:
receiveString();
break;
case Constants::IMAGE:
receiveImage();
break;
};
}
Ref<Tip, Owner> HaxeMessageSyntax::parse(String message)
{
Ref<Tip, Owner> tip;
Ref<Token, Owner> rootToken = match(message);
if (rootToken) {
Ref<Token> token = rootToken->firstChild();
if (token->rule() == typeTip_) {
token = token->firstChild();
if (token->rule() == value_) {
String typeString = readValue(message, token);
tip = new TypeTip(readType(typeString));
}
}
else if (token->rule() == membersTip_) {
Ref<Members, Owner> members = new Members(token->countChildren());
int memberIndex = 0;
token = token->firstChild();
while (token) {
String name, description;
Ref<Type, Owner> type;
Ref<Token> child = token->firstChild();
while (child) {
if (child->rule() == memberName_)
name = message->copy(child->i0(), child->i1());
else if (child->rule() == memberType_)
type = readType(readValue(message, child));
else if (child->rule() == memberDescription_)
description = message->copy(child->i0(), child->i1());;
child = child->nextSibling();
}
// debug("\"%%\",\"%%\",\"%%\"\n", name, type, description);
members->set(memberIndex++, new Member(name, type, description));
token = token->nextSibling();
}
tip = new MembersTip(members);
}
}
return tip;
}
QString TableManagement::buildCreateTable(){
QString tag = "CREATE TABLE IF NOT EXISTS " + nameTable() + " (";
const QMetaObject *metaObject = object()->metaObject();
for (int i = 1; i < metaObject->propertyCount(); ++i) {
QString propertyName = QString::fromUtf8(metaObject->property(i).name());
tag += propertyName + ' ' +
readType(object()->property(propertyName.toLatin1().constData()));
if(i != metaObject->propertyCount() - 1) tag += ", ";
else tag += ')';
}
return tag;
}
void getCommand(){
packageCounter++;
if(packageCounter == 4){
readType();
}
if(packageCounter == packageSize){
packageCounter = 0;
packageSize = 4;
getMotion(package);
}
}
void Vfile::read_sections(ifstream &v) {
int len;
char buffer_name[28];
while(1) {
readType(v, &len);
if (len==0) {
cout << "Reached end of sections" << endl;
v.seekg(28, std::ios_base::cur); // skip rest of blank header
return;
} else {
cout << "Section length: " << len << endl;
v.read(buffer_name, 28);
cout << "Section name: " << buffer_name << endl;
if (strcmp(buffer_name, "DATAGROUP")==0) {
read_datagroups(v, len);
} else {
v.seekg(len, std::ios_base::cur);
}
}
}
return;
}
void CompilationEngine::compileVarDec()
{
/* 'var' type varName (',' varName)* ';' */
tagNonTerminal("varDec");
readKeyword("var", Keyword::kVAR);
nextToken();
readType();
nextToken();
readIdentifier();
nextToken();
while (jt.tokenType() == TokenType::kSYMBOL && jt.symbol() == ',') {
readSymbol(',');
nextToken();
readIdentifier();
nextToken();
}
readSymbol(';');
untagNonTerminal("varDec");
nextToken();
}
void BinReader::readModules()
{
// modules
int numModules = bytes->readInt();
for (int i = 0; i < numModules; i++)
{
const char *type = readPoolString();
const char *name = readPoolString();
const char *version = readPoolString();
Module *module = Module::create(assembly, name);
int numTypes = bytes->readInt();
for (int j = 0; j < numTypes; j++)
{
Type *type = readType();
module->addType(type);
}
}
}
int receiveFile(int sock){
fp = fopen(file_path,"w");
if(fp == NULL)
{
perror("open");
exit(EXIT_FAILURE);
}
int test =4;
while(1){
char buf[BUFFSIZE];
test--;
if(recvfrom(sock, &buf, BUFFSIZE, 0, (struct sockaddr*) &sin6_cli, &sin6len) == -1){
perror("Connection Lost");
exit(EXIT_FAILURE);
}
int type = readType(buf[0]);
int seq = readSeqNumber(buf[1]);
printf("Received test:%d seq:%d\n", test, seq);
if(type == PTYPE_DATA && test !=0){
window_start = (window_start+1)%MAXWINDOWSIZE;
if(seq == seq_number && xor_count !=0){
memcpy(&buffer[(XORFREQ-xor_count)*PAYLOADSIZE], &buf[4], PAYLOADSIZE);
msg_rvcd++;
xor_count--;
seq_number = (seq_number+1)%256;
window_end = (window_end+ 1)%MAXWINDOWSIZE;
sendMsg(sock, PTYPE_ACK, seq_number, window_end);
printf("Ack sent %d %d\n", seq_number, window_end);
last_length =readLength(buf);
if(last_length<512){
xor_count=0;
}
}else{// else discard packet, send last ack again.
sendMsg(sock, PTYPE_ACK, seq_number, window_end);
}
}else if(type == PTYPE_XOR){
computeXor(buffer);
int seq = readSeqNumber(buf[1]);
if(seq == seq_number && xor_count == 0){
if(checkXor(buf)){
xor_count = XORFREQ;
seq_number= (seq_number+1)%256;
window_end = (window_end+ 1)%MAXWINDOWSIZE;
sendMsg(sock, PTYPE_ACK, seq_number, window_end);
if(last_length<512){return 0;}
msg_rvcd=0;
}else{
// Make choice if XOR is wrong
/* No ack sent, all window will be retransmitted*/
}
}
}
if(test ==0){
test = 1000;
}
}
fclose(fp);
}
void DetailExcelWidget::getSheetData(Worksheet* sheet)
{
sheetName.push_back(sheet->sheetName());
readHead(sheet);
readType(sheet);
}
int Datagroup::read(ifstream &v) {
short Reclen;
readType(v, &Reclen);
if (Reclen==0) {
cout << "Found datagroups null terminator" << endl;
return 2;
}
if (VDEBUG) cout << "Datagroup record length " << Reclen << endl;
readType(v, &GroupID);
char DL;
readType(v, &DL);
if (DL != 0) {
char * buffer_desc = new char[DL];
v.read(buffer_desc, DL);
Desc = string(buffer_desc);
delete [] buffer_desc;
} else {
cout << "Huh, no desc for datagroup record" << endl;
}
readType(v, &Type);
char Width;
readType(v, &Width);
// because I don't trust the next generation of computers
// not to switch datatypes
if (Type==1)
assert(Width==1 && sizeof(char)==1);
if (Type==2)
assert(Width==1 && sizeof(char)==1);
if (Type==3)
assert(Width==2 && sizeof(short)==2);
if (Type==4)
assert(Width==4 && sizeof(int)==4);
if (Type==5)
assert(Width==sizeof(float));
if (Type==6)
assert(Width==sizeof(double));
if (Type==7)
assert(Width==1 && sizeof(char)==1);
readType(v, &FR);
cout << "Framerate is " << FR << endl;
short NumDOFS;
readType(v, &NumDOFS);
cout << "Got " << int(NumDOFS) << " DOFs in datagroup" << endl;
for (int i = 0; i < NumDOFS; ++i) {
char len;
readType(v, &len);
if (VDEBUG) cout << "DOFlabel " << i << "'s length: " << int(len) << endl;
char * buffer_DOFlabel = new char[len];
v.read(buffer_DOFlabel, len);
DOFlabels.push_back(string(buffer_DOFlabel));
delete [] buffer_DOFlabel;
if (VDEBUG) cout << "DOFlabel " << i << "'s contents: " << DOFlabels[i] << endl;
}
if (v.fail())
cout << "ERROR: datagroup read, but fail bit is set" << endl;
else
cout << "Datagroup read successfully" << endl;
return Reclen + 2;
}
bool KDesktopFile::hasLinkType() const
{
return readType() == QLatin1String("Link");
}
bool KDesktopFile::hasApplicationType() const
{
return readType() == QLatin1String("Application");
}
bool KDesktopFile::hasDeviceType() const
{
return readType() == QLatin1String("FSDevice");
}
void ChanneledJsonDecompressor::read(dynamic* outObj) {
uint8_t curType = readType();
// Map
if (inRange(curType, TYPE_SHORT_MAP_BASE, SHORT_TYPE_LENGTH)) {
readMap(curType - TYPE_SHORT_MAP_BASE, outObj);
return;
}
if (curType == TYPE_LONG_MAP) {
int64_t mapLength = readVarInt(CHANNEL_MAPLEN);
readMap(mapLength, outObj);
return;
}
// Array
if (inRange(curType, TYPE_SHORT_ARRAY_BASE, SHORT_TYPE_LENGTH)) {
readArray(curType - TYPE_SHORT_ARRAY_BASE, outObj);
return;
}
if (curType == TYPE_LONG_ARRAY) {
int64_t arrayLength = readVarInt(CHANNEL_ARRAYLEN);
readArray(arrayLength, outObj);
return;
}
// String - different types
if (curType == TYPE_MEMOISED_STRING) {
int memoisedIdx = readVarInt(CHANNEL_MEMOSTRS);
*outObj = memoStrings_[memoisedIdx];
return;
}
if (inRange(curType, TYPE_SHORT_STRING_BASE, SHORT_TYPE_LENGTH)) {
uint32_t stringLength = curType - TYPE_SHORT_STRING_BASE;
readString(stringLength, CHANNEL_STRS, outObj);
memoStrings_[memoStringsNext_] = outObj->asString();
++memoStringsNext_;
return;
}
if (curType == TYPE_STRING_SIZE) {
uint32_t stringLength = readVarInt(CHANNEL_STRLEN);
readString(stringLength, CHANNEL_STRS, outObj);
memoStrings_[memoStringsNext_] = outObj->asString();
++memoStringsNext_;
return;
}
// Boolean
if (curType == TYPE_BOOL_TRUE) {
*outObj = true;
return;
}
if (curType == TYPE_BOOL_FALSE) {
*outObj = false;
return;
}
// Integer
if (inRange(curType, TYPE_SMALL_INT_BASE, SHORT_TYPE_LENGTH)) {
*outObj = curType - TYPE_SMALL_INT_BASE;
return;
}
if (curType == TYPE_LONG_INT) {
*outObj = readVarInt(CHANNEL_INTS);
return;
}
// None
if (curType == TYPE_NONE) {
*outObj = nullptr;
return;
}
// Double
if (curType == TYPE_DOUBLE) {
readDouble(outObj);
return;
}
//TODO(noamler) - unknown type error handling. Log?
*outObj = nullptr;
}
static void readHypo(FILE *f, Hypo h) {
h->bt = readTag(f);
h->var = readCId(f);
h->ty = readType(f);
}
static Expr readExpr(FILE *f) {
int tag = readTag(f);
switch (tag) {
case TAG_ABS:
{
ExprAbs e = (ExprAbs) malloc(sizeof(struct _ExprAbs));
e->_.tag = tag;
e->bt = readTag(f);
e->var = readCId(f);
e->body = readExpr(f);
return ((Expr) e);
}
case TAG_APP:
{
ExprApp e = (ExprApp) malloc(sizeof(struct _ExprApp));
e->_.tag = tag;
e->left = readExpr(f);
e->right = readExpr(f);
return ((Expr) e);
}
case TAG_LIT:
{
ExprLit e = (ExprLit) malloc(sizeof(struct _ExprLit));
e->_.tag = tag;
e->lit = readLiteral(f);
return ((Expr) e);
}
case TAG_MET:
{
ExprMeta e = (ExprMeta) malloc(sizeof(struct _ExprMeta));
e->_.tag = tag;
e->id = readInt(f);
return ((Expr) e);
}
case TAG_FUN:
{
ExprFun e = (ExprFun) malloc(sizeof(struct _ExprFun));
e->_.tag = tag;
e->fun = readCId(f);
return ((Expr) e);
}
case TAG_VAR:
{
ExprVar e = (ExprVar) malloc(sizeof(struct _ExprVar));
e->_.tag = tag;
e->index = readInt(f);
return ((Expr) e);
}
case TAG_TYP:
{
ExprTyped e = (ExprTyped) malloc(sizeof(struct _ExprTyped));
e->_.tag = tag;
e->e = readExpr(f);
e->ty = readType(f);
return ((Expr) e);
}
case TAG_IMP:
{
ExprImplArg e = (ExprImplArg) malloc(sizeof(struct _ExprImplArg));
e->_.tag = tag;
e->e = readExpr(f);
return ((Expr) e);
}
default:
__pgf_panic("Unknown expression tag");
}
}
ResourceID::ResourceID(std::string name_):
type{readType(name_)},
name{readName(std::move(name_))}
{}
return TagValue::StringVector;
case TagValue::TimeVector:
return TagValue::TimeVector;
default:
error(Event::ParseError, "Invalid type for tag value: %d", x);
return TagValue::Null;
}
}
std::istream & operator>>(std::istream& in, TagValue &t) {
switch (in.peek()) {
case 'b':
// binary blob
{
in.get();
TagValue::Type type = readType(in.get());
// skip the next two chars (they are for word-alignment and future proofing)
if (in.get() != 0 || in.get() != 0) {
goto error;
}
switch (type) {
case TagValue::Null: {
TagValue nullTag;
t = nullTag;
return in;
}
case TagValue::Int: {
int x;
in.read((char *)&x, sizeof(int));
t = x;
return in;
