Expression* APLreader::readExpression()
{
// see if it is a scalar value
if ((*p_ == '-') && isdigit(*(p_ + 1)))
{
p_++;
return readAPLscalar(-readInteger());
}
if (isdigit(*p_))
{
return readAPLscalar(readInteger());
}
// see if it is a vector constant
if (*p_ == '(')
{
p_++;
skipNewlines();
if (isdigit(*p_))
{
return readAPLvector(0);
}
return readList();
}
// else default
return LispReader::readExpression();
}
int main(){
char allStar = '\0', regularMVP = '\0', worldMVP = '\0', goldGlove = '\0', silverSlug = '\0',
homeRun = '\0', battingAve = '\0', gender = '\0';
int bonus = 0, num1 = 0, num2 = 0, num3 = 0, num4 = 0, num5 = 0,
activityLevel = 0, menuChoice = 0, i = 0;
double weight = 0, height = 0, age = 0, bmr = 0, calories = 0, result = 0;
FILE *inputFile = NULL;
//PROBLEM 1
inputFile = openInputFile();
/*
gender = readCharacter(inputFile);
age = readNumber(inputFile);
weight = readNumber(inputFile);
height = readNumber(inputFile);
bmr = computeBMR(gender, weight, height, age);
activityLevel = determineActivityLevel();
calories = computeCalories(bmr, activityLevel);
printf("Calories needed per day are: %.0lf\n", calories);
//PROBLEM 2
allStar = getBaseballAchievements("All-Star Game appearance");
bonus += determineBonus(allStar, 25000);
regularMVP = getBaseballAchievements("Regular Season MVP");
bonus += determineBonus(regularMVP, 75000);
worldMVP = getBaseballAchievements("World Series MVP");
bonus += determineBonus(worldMVP, 100000);
goldGlove = getBaseballAchievements("Gold Glove award");
bonus += determineBonus(goldGlove, 50000);
silverSlug = getBaseballAchievements("Silver Slugger award");
bonus += determineBonus(silverSlug, 35000);
homeRun = getBaseballAchievements("Home run champ");
bonus += determineBonus(homeRun, 25000);
battingAve = getBaseballAchievements("Batting average champ");
bonus += determineBonus(battingAve, 25000);
printf("Total player bonus is %d\n", bonus);
int i = 0;*/
//PROBLEM 3
num1 = readInteger(inputFile);
num2 = readInteger(inputFile);
num3 = readInteger(inputFile);
num4 = readInteger(inputFile);
num5 = readInteger(inputFile);
while (i < 3){
menuChoice = displayMenu();
result = calculateResult(menuChoice, num1, num2, num3, num4, num5);
displayResult(menuChoice, result);
i++;
}
return 0;
}
int DLNTinput(int len, char *buffer)
{
extern REISENDER_TYP reit;
extern BEZEICHNUNG bez;
extern TEXTE txt;
extern int sprache;
char *to_buffers[MAX_MENU_ITEMS];
int status=(int)MPOK;
status = UtilSplitMenubuffer(buffer, to_buffers, (char)NULL);
if (status != MPOK)
{
UtilMsg((int)MPE_CUTBUFFERIN, MSGTYP_ERROR, NULL);
reit.rkr_id = (int)_UNDEF;
return((int)MPERROR);
}
if (ACTIONTYP == (int)INSERT)
{
reit.rkr_id=(int)_UNDEF;
reit.textid=(int)_UNDEF;
txt.textid=(int)_UNDEF;
reit.vonalter = (int)_UNDEF;
reit.bisalter = (int)_UNDEF;
}
bez.s_id=(int)sprache;
bez.typ=(int)_REISENDER_TYP;
(void)copyTextTo(bez.bez, to_buffers[MDLNT_BEZ], (int)_BEZLEN);
if (*bez.bez != NULL)
{
(void)copyTextTo(reit.dlncode, to_buffers[MDLNT_CODE], (int)_CHAR10);
status = readInteger(&reit.vonalter, to_buffers[MDLNT_VONALTER]);
if (status == (int)MPERROR)
reit.vonalter = (int)_UNDEF;
status = readInteger(&reit.bisalter, to_buffers[MDLNT_BISALTER]);
if (status == (int)MPERROR)
reit.bisalter = (int)_UNDEF;
txt.typ=(int)_REISENDER_TYP;
txt.s_id=sprache;
txt.textid=reit.textid;
reit.textid=xTxtWrite(to_buffers[MDLNT_TXT]);
status=WriteEntry((int)_REISENDER_TYP, (char *)&reit, &bez);
if (status == (int)MPERROR)
reit.rkr_id=(int)_UNDEF;
/*!!! WriteInfo hier */
}
UtilSplitFreeMenubuffer(to_buffers);
return(status);
}
bool TextureLoader::readHeader(std::istream& fin) {
if ((m_width = readInteger(fin)) < 0) {
std::cout << "PPM: invalid width" << std::endl;
return false;
}
if ((m_height = readInteger(fin)) < 0) {
std::cout << "PPM: invalid height" << std::endl;
return false;
}
if ((m_maxVal = readInteger(fin)) != 255) {
std::cout << "PPM: max color not 255" << std::endl;
return false;
}
}
Snap* storeBitmap(const char* fname)
{
// Open the file to read the bitmap snap content
std::ifstream in;
in.open(fname, std::ifstream::binary);
assert(!in.fail() || !"Could not find file");
char store[2];
in.read(store, 2);
// Check for the first two characters of the snap file, if it has
// "B" and "M" then its a bmp file
assert(store[0] == 'B' && store[1] == 'M' || !"Not a bitmap file");
in.ignore(8);
int info = readInteger(in);
// Fetch the header content
int sizeH = readInteger(in);
int w, h;
w = readInteger(in);
h = readInteger(in);
in.ignore(2);
assert(readShort(in) == 24 || !"Image is not 24 bits per pixel");
assert(readShort(in) == 0 || !"Image is compressed");
int BPerRCount = ((w * 3 + 3) / 4) * 4 - (w * 3 % 4);
int sizeA = BPerRCount * h;
vishakArray<char> pixelArrayObj(new char[sizeA]);
in.seekg(info, std::ios_base::beg);
in.read(pixelArrayObj.get(), sizeA);
//Get the data into the right format
vishakArray<char> pixelArrayObj2(new char[w * h * 3]);
for(int y = 0; y < h; y++) {
for(int x = 0; x < w; x++) {
for(int c = 0; c < 3; c++) {
pixelArrayObj2[3 * (w * y + x) + c] =
pixelArrayObj[BPerRCount * y + 3 * x + (2 - c)];
}
}
}
in.close();
return new Snap(pixelArrayObj2.release(), w, h);
}
APLValue* APLreader::readAPLvector(int size)
{
skipNewlines();
// if at end of list, make new vector
if (*p_ == ')')
{
p_++;
return new APLValue(size);
}
// else we better have a digit, save it and get the rest
int sign = 1;
if (*p_ == '-')
{
sign = -1;
p_++;
}
if (!isdigit(*p_))
{
error("ill formed apl vector constant");
}
int val = sign* readInteger();
APLValue* newval = readAPLvector(size + 1);
newval->atPut(size, val);
return newval;
}
bool parseList(VLXList* list)
{
std::string str;
// tag
if (!readString(str))
return false;
list->setTag(str.c_str());
// read value count
long long count = 0;
if (!readInteger(count))
return false;
// values
for(int i=0; i<count; ++i)
{
VLXValue val;
if (!readValue(val))
return false;
else
list->value().push_back(val);
}
return true;
}
bool BranchState::readInteger( Token::Argument& argument )
{
assert( argument.type() == Token::Argument::INTEGER_REGISTER );
if( argument.content() == Token::Argument::REGISTER )
{
return readInteger( argument.regNumber() );
}
else if( argument.content() == Token::Argument::ALIAS )
{
std::map< std::string, State >::iterator i = m_integers.find( argument.alias() );
// has this alias been written already?
if( i == m_integers.end() )
return false;
// make sure no uninitialized portion of the alias is read
if( !i->second.fields() )
return false;
// update dependency information
updateDependency( argument, i->second, Alias::INTEGER, i->first, true );
}
else return false;
return true;
}
int main()
{
string nombre;
int nota;
writeLnString("Ingrese un nombre: ");
readString(nombre);
writeLnString("Ingrese una nota: ");
readInteger(nota);
writeString("La condicion del alumno " + nombre + " es ");
if(1 <= nota && nota <= 3)
{
writeLnString("INSUFICIENTE");
}
if(4 <= nota && nota <= 6)
{
writeLnString("BUENO");
}
if(7 <= nota && nota <= 8)
{
writeLnString("MUY BUENO");
}
return 0;
}
/* read a vector of wstring objects from the UnMarshal object
*/
void UnMarshal::Read(vector<wstring>& vws)
{
MarshalDataType dt = readDataType();
// check for stream read error
CHECK_READ_ERROR(m_strm);
if (dt != MTYPE_VECTOR_WSTRING)
{
throw SCXMarshalFormatException(MTYPE_VECTOR_WSTRING, dt, SCXSRCLOCATION);
}
int vecSize = readInteger();
CHECK_READ_ERROR(m_strm);
vws.clear();
for(int i = 0; i < vecSize; i++)
{
wstring ws;
Read(ws);
vws.push_back(ws);
}
}
void NSParser::readSensorIdentifier(Symbol *symbol, int& sensorType, int &id)
{
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
for(Symbol* child: nt->children)
{
switch(child->symbolIndex)
{
case SYM_INTEGER:
case SYM_ID:
{
Symbol* intSymbol = searchChild(child, SYM_INTEGER);
id = readInteger(intSymbol);
break;
}
case SYM_SENSOR2:
{
sensorType = readSensorType(child);
break;
}
}
}
}
}
/* read a vector of SCXRegexWithIndex objects from the UnMarshal object
*/
void UnMarshal::Read(vector<SCXRegexWithIndex>& vri)
{
MarshalDataType dt = readDataType();
// check for stream read error
CHECK_READ_ERROR(m_strm);
if (dt != MTYPE_VECTOR_REGEX_INDEX)
{
throw SCXMarshalFormatException(MTYPE_VECTOR_REGEX_INDEX, dt, SCXSRCLOCATION);
}
int vecSize = readInteger();
CHECK_READ_ERROR(m_strm);
vri.clear();
for(int i = 0; i < vecSize; i++)
{
SCXRegexWithIndex ri;
Read(ri);
vri.push_back(ri);
}
}
/* read a wstring from the UnMarshal object
*/
void UnMarshal::Read(wstring& ws)
{
MarshalDataType dt = readDataType();
// check for stream read error
CHECK_READ_ERROR(m_strm);
if (dt != MTYPE_WSTRING)
{
throw SCXMarshalFormatException(MTYPE_WSTRING, dt, SCXSRCLOCATION);
}
int strSize = readInteger();
CHECK_READ_ERROR(m_strm);
// Read in the wstring as a list of bytes
vector<char> buf(strSize, '\0');
m_strm.read(&buf[0], strSize);
CHECK_READ_ERROR(m_strm);
// Create a real wstring of the appropriate size
size_t nr = strSize / sizeof(wchar_t);
vector<wchar_t> wbuf(nr + 1 /* Null byte */, L'\0');
memcpy(&wbuf[0], (void*) &buf[0], strSize);
// Return the final wstring
ws = wstring(&wbuf[0]);
}
shared_ptr<IfcDayInMonthNumber> IfcDayInMonthNumber::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcDayInMonthNumber>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcDayInMonthNumber>(); }
shared_ptr<IfcDayInMonthNumber> type_object( new IfcDayInMonthNumber() );
readInteger( arg, type_object->m_value );
return type_object;
}
//--------------ADD---------------------
void ui_add(UI* ui){
char* name = readString("Give name: ");
float concentration = readFloat("Give concentration: ");
int quantity = readInteger("Give quantity: ");
float price = readFloat("Give price: ");
contr_add(ui -> contr, name, concentration, quantity, price);
printf("-----------------\n");
}
int NSParser::readSubId(Symbol *symbol)
{
Symbol* intSymbol = searchChild(symbol, SYM_INTEGER, true);
if (intSymbol)
return readInteger(intSymbol);
return -1;
}
void DialogEditSIMDRegister::onIntegerEdited(QObject* sender,const std::array<NumberEdit*,numBytes/sizeof(Integer)>& elements)
{
const auto changedElementEdit=dynamic_cast<NumberEdit*>(sender);
std::size_t elementIndex=std::find(elements.begin(),elements.end(),changedElementEdit)-elements.begin();
Integer value=readInteger(elements[elementIndex]);
std::memcpy(&value_[elementIndex*sizeof(value)],&value,sizeof(value));
updateAllEntriesExcept(elements[elementIndex]);
}
/* register locations
unsigned char Sensor1_mode; //0x8A
unsigned char Sensor2_mode; //0x8B
unsigned int Sensor_1_reading; //0x70
unsigned int Sensor_2_reading; //0x8E
*/
int EVShieldBank::sensorReadRaw(uint8_t which_sensor)
{
/*
* sensor can only be 1 or 2,
* otherwise return -1;
*/
switch (which_sensor) {
case 1:
return readInteger(SH_S1_ANALOG);
break;
case 2:
return readInteger(SH_S2_ANALOG);
break;
default:
return -1;
break;
}
}
int NSParser::readSpeed(Symbol* symbol)
{
int speed = 100;
Symbol* intergerSymbol = searchChild(symbol, SYM_INTEGER);
if (intergerSymbol)
speed = readInteger(intergerSymbol);
return speed;
}
void testInteger(
char *e1, char *e2, Integer (*fct)(Integer e1, Integer e2), char *fctName,
char *res
)
{
Integer e_e1 = readInteger(e1)
, e_e2 = readInteger(e2)
, e_res = readInteger(res);
Integer e_compute = fct(e_e1, e_e2);
assert(equals(e_res, e_compute));
freeInteger(e_e1);
freeInteger(e_e2);
freeInteger(e_res);
freeInteger(e_compute);
printf("%s %s %s = %s\n", e1, fctName, e2, res);
}
bool readString(std::string& str)
{
long long len = 0;
if (!readInteger(len))
return false;
VL_CHECK(len >= 0 );
if (len < 0)
return false;
if (len == 0)
return true;
str.resize((size_t)len);
bool ok = (size_t)inputFile()->read(&str[0], str.length()) == str.length();
return ok;
}
/* read an integer from the UnMarshal object
*/
void UnMarshal::Read(int& val)
{
MarshalDataType dt = readDataType();
// check for stream read error
CHECK_READ_ERROR(m_strm);
if (dt != MTYPE_INT)
{
throw SCXMarshalFormatException(MTYPE_INT, dt, SCXSRCLOCATION);
}
val = readInteger();
CHECK_READ_ERROR(m_strm);
}
/**
* Convert the byte array a bundle. Assumes that the byte array is a bundle.
* @return a bundle containing the data specified in the byte stream
*/
OSCBundle& OSCByteArrayToMsgConverter::convertBundle()
{
iStreamPosition = 8;
QDateTime timestamp = readTimeTag();
OSCBundle* bundle = new OSCBundle(timestamp);
OSCByteArrayToMsgConverter* myConverter = new OSCByteArrayToMsgConverter();
while(iStreamPosition < iBytesLength) {
// recursively read through the stream and convert packets you find
qint32 packetLength = readInteger().toInt();
QByteArray packetBytes(iBytes->constData()+iStreamPosition,packetLength);
OSCPacket& packet = myConverter->convert(&packetBytes, packetLength);
bundle->addPacket(packet);
}
delete myConverter;
return *bundle;
}
RedisProto::ParseState RedisProto::parse(char *s, int len, RedisProtoParseResult *result)
{
int ret = 0;
switch (s[0]) {
case '+':
result->type = RedisProtoParseResult::Status;
ret = readStatus(s, len, &(result->tokens[0]));
break;
case '-':
result->type = RedisProtoParseResult::Error;
ret = readError(s, len, &(result->tokens[0]));
break;
case ':':
result->type = RedisProtoParseResult::Integer;
ret = readInteger(s, len, &result->integer);
break;
case '$':
result->type = RedisProtoParseResult::Bulk;
ret = readBulk(s, len, &(result->tokens[0]));
break;
case '*':
result->type = RedisProtoParseResult::MultiBulk;
ret = readMultiBulk(s, len, result->tokens, &result->tokenCount);
break;
default: {
int stringlen = 0;
result->type = RedisProtoParseResult::Bulk;
ret = readTextEndByCRLF(s, len, &stringlen);
if (ret > 0) {
result->tokens[0].s = s;
result->tokens[0].len = stringlen;
}
}
break;
}
switch (ret) {
case READ_AGAIN:
return ProtoIncomplete;
case READ_ERROR:
return ProtoError;
default:
result->protoBuff = s;
result->protoBuffLen = ret;
return ProtoOK;
}
}
bool DefaultLexer::readFloatExp(char startChar) {
putChar(startChar); // put 'e' or 'E'
skipChar();
char c = lookChar();
if (c == '+' || c == '-') {
putChar(c);
skipChar();
} else
return false;
c = lookChar();
if (isDigit(c)) {
readInteger(c);
return true;
}
return false;
}
int main(int argc, char ** argv)
{
if (argc < 4)
{
printf("need four file names: type, input, output");
return EXIT_FAILURE;
}
if (strcmp(argv[1], "i") == 0) /* sort integers */
{
int numInteger = 0;
int * arrInteger = NULL;
arrInteger = readInteger(argv[2], & numInteger);
if (numInteger == 0)
{
return EXIT_FAILURE;
}
printInteger(arrInteger, numInteger);
sortInteger(arrInteger, numInteger);
printInteger(arrInteger, numInteger);
saveInteger(argv[3], arrInteger, numInteger);
freeInteger(arrInteger, numInteger);
return EXIT_SUCCESS;
}
if (strcmp(argv[1], "s") == 0) /* sort strings */
{
int numString = 0;
char * * arrString = NULL;
arrString = readString(argv[2], & numString);
if (numString == 0)
{
return EXIT_FAILURE;
}
printString(arrString, numString);
sortString(arrString, numString);
printString(arrString, numString);
saveString(argv[3], arrString, numString);
freeString(arrString, numString);
return EXIT_SUCCESS;
}
/* unknown type */
return EXIT_FAILURE;
}
void JsonSchema::readValues(cJSON *childProperties, PropertiesPtr property ,
const std::string &attType)
{
if (attType == "string")
{
readString(childProperties, property);
}
else if (attType == "integer")
{
readInteger(childProperties, property);
}
else if (attType == "array")
{
readArray(childProperties, property);
}
else if (attType == "number")
{
readDouble(childProperties, property);
}
}
void run(UI *self) {
while(1) {
ui_printMenu();
int cmd = readInteger("Give a command: ");
switch(cmd) {
case 0:
return ;
break;
case 1:
ui_add(self);
break;
case 2:
ui_showAll(self);
break;
case 3:
ui_delete(self);
break;
case 4:
ui_update(self);
break;
/*
case 5:
ui_filter(self);
break;
case 6:
ui_filterByQuantity(self);
break;
h*/
case 7:
ui_undo(self);
break;
case 8:
ui_redo(self);
break;
default:
printf("You entered a wrong command");
}
}
}
static Pointer readForm(Tokeniser* t)
{
if (tokeniser_eof(t)) {
return nil_make();
}
Pointer ret = tokeniser_token(t);
// If ret is a string, it's ready to return
if (ret.type == Type_symbol) {
const char* token = symbol_get(ret);
int intValue;
if (util_streq(token, "(")) {
tokeniser_next(t); // consume the '(', read the list and
return readList(t); // return immediately to avoid hitting the
// tokeniser_next() below
}
else if (util_streq(token, "nil")) {
ret = nil_make();
}
else if (util_streq(token, "true")) {
ret = boolean_make(1);
}
else if (util_streq(token, "false")) {
ret = boolean_make(0);
}
else if (readInteger(token, &intValue)) {
ret = integer_make(intValue);
}
else {
// Insert the symbol into the symbol table. We may or may not get
// the same symbol back.
ret = symtab_insert(ret);
}
}
PUSH(ret);
tokeniser_next(t);
return POP();
}
void KAbstractHdrParserPrivate::parseDimension()
{
int *size;
PixelOrder order;
// First, get the dimension order
switch (nextChar())
{
case '-':
order = PixelOrder::Negative;
break;
case '+':
order = PixelOrder::Positive;
break;
default:
qFatal("Expected {-+} sign for pixel order! Got, `%c`", currChar());
break;
}
// Next, get what dimension we are parsing.
switch (nextChar())
{
case 'Y':
m_yOrder = order;
size = &m_ySize;
break;
case 'X':
m_xOrder = order;
size = &m_xSize;
break;
default:
qFatal("Expected {XY} sign for dimension! Got, `%c`", currChar());
break;
}
// Find the dimensionality
nextChar(); nextChar();
(*size) = readInteger();
nextChar();
}
