void printResponseCb(ZBRxIoSampleResponse& rx, uintptr_t data) {
Print *p = (Print*)data;
p->println(F("ZBRxIoSampleResponse received:"));
printField(p, F(" From: 0x"), rx.getRemoteAddress64());
printField(p, F(" From: 0x"), rx.getRemoteAddress16());
printField(p, F(" Receive options: 0x"), rx.getOption());
for (uint8_t i = 0; i < 16; ++i) {
if (rx.isDigitalEnabled(i)) {
p->print(F(" Digital pin "));
p->print(i);
p->print(F(": "));
p->print(rx.isDigitalOn(i) ? "HIGH" : "LOW");
p->println();
}
}
for (uint8_t i = 0; i < 8; ++i) {
if (rx.isAnalogEnabled(i)) {
p->print(F(" Analog pin "));
p->print(i);
p->print(F(": 0x"));
printHex(*p, rx.getAnalog(i));
p->println();
}
}
}
void printResponseCb(ZBTxStatusResponse& status, uintptr_t data) {
Print *p = (Print*)data;
p->println(F("ZBTxStatusResponse received:"));
printField(p, F(" FrameId: 0x"), status.getFrameId());
printField(p, F(" To: 0x"), status.getRemoteAddress());
printField(p, F(" Delivery status: 0x"), status.getDeliveryStatus());
printField(p, F(" Discovery status: 0x"), status.getDiscoveryStatus());
}
void printResponseCb(Rx64IoSampleResponse& rx, uintptr_t data) {
Print *p = (Print*)data;
p->println("Rx64IoSampleResponse received:");
printField(p, F(" From: 0x"), rx.getRemoteAddress64());
printField(p, F(" Rssi: 0x"), rx.getRssi());
printField(p, F(" Receive options: 0x"), rx.getOption());
printField(p, F(" Number of samples: 0x"), rx.getSampleSize());
printSamples(p, rx);
}
OFile& OFile::printField( Value* val, const double& v ) {
printField( val->getName(), v );
if( val->isPeriodic() ) {
std::string min, max; val->getDomain( min, max );
printField( "min_" + val->getName(), min );
printField("max_" + val->getName(), max );
}
return *this;
}
void printResponseCb(Rx64Response& rx, uintptr_t data) {
Print *p = (Print*)data;
p->println("Rx64Response received:");
printField(p, F(" From: 0x"), rx.getRemoteAddress64());
printField(p, F(" Rssi: 0x"), rx.getRssi());
printField(p, F(" Receive options: 0x"), rx.getOption());
if (rx.getDataLength() > 8)
p->print(" Payload:\r\n ");
else
p->print(" Payload: ");
printHex(*p, rx.getFrameData() + rx.getDataOffset(), rx.getDataLength(), F(" "), F("\r\n "), 8);
p->println();
}
void PrintOutputResults(LPTICKETRESULTS ticketResults){
int i;
printf ("Results after post-processing----------------------------------------\n");
printf("Status= %d\n", ticketResults->status);
printTicketType(ticketResults->type, ticketResults->typeCnf);
for(i=0;i<NUMFIELDS_RESULTS;i++){
if(ticketResults->fieldsResults[i].name[0] != 0){
if(strcmp(ticketResults->fieldsResults[i].name, "NUMBERS") == 0) printField(&ticketResults->fieldsResults[i]);
if(strcmp(ticketResults->fieldsResults[i].name, "PLAYER") == 0) printField(&ticketResults->fieldsResults[i]);
if(strcmp(ticketResults->fieldsResults[i].name, "DATE") == 0) printField(&ticketResults->fieldsResults[i]);
}
}
printf ("--------------------------------------------------------------------\n");
}
void printResponseCb(RemoteAtCommandResponse& at, uintptr_t data) {
Print *p = (Print*)data;
p->println("AtRemoteCommandResponse received:");
printField(p, F(" To: 0x"), at.getRemoteAddress64());
printField(p, F(" To: 0x"), at.getRemoteAddress16());
p->print(F(" Command: "));
p->write(at.getCommand(), 2);
p->println();
printField(p, F(" Status: 0x"), at.getStatus());
if (at.getValueLength()) {
p->print(F(" Value: "));
printHex(*p, at.getValue(), at.getValueLength(), F(" "), NULL);
p->println();
}
}
static void joinerValidateFields(struct joiner *joiner, struct hash *fieldHash,
char *oneIdentifier)
/* Make sure that joiner refers to fields that exist at
* least somewhere. */
{
struct joinerSet *js;
struct joinerField *jf;
for (js=joiner->jsList; js != NULL; js = js->next)
{
if (oneIdentifier == NULL || wildMatch(oneIdentifier, js->name))
{
for (jf = js->fieldList; jf != NULL; jf = jf->next)
{
if (!fieldExists(fieldHash, js, jf))
{
if (!js->expanded)
{
fprintf(stderr, "Error: ");
printField(jf, stderr);
fprintf(stderr, " not found in %s line %d of %s\n",
js->name, jf->lineIx, joiner->fileName);
}
}
}
}
}
}
int main(int argc, char *argv[]) {
pthread_t pth;
int error;
// запускаем поток для сервера
if (error = pthread_create(&pth, NULL, &serverHandler, NULL)) {
printf("Error with create server thread\n");
return 1;
}
pthread_t life;
// потоки, которые считают конфигурацию жизни
while(1) {
printField();
printf("\n");
if (error = pthread_create(&life, NULL, &lifeStep, NULL)) {
printf("Error with create life thread\n");
return 1;
}
sleep(1);
// если не завершился за секунду, выдать ошибку
if ((error = pthread_kill(life, 0)) == 0) {
pthread_cancel(life);
printf("Thread running longer than 1 second\n");
return 2;
}
}
return 0;
}
extern void printFields (void)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE (fieldDescs); i++)
printField (i);
}
bool checkNextStep() {
printField();
struct position nextPosition;
nextPosition.i = currentPosition.i + shiftList[currentDirection][0];
nextPosition.j = currentPosition.j + shiftList[currentDirection][1];
enum state_type next;
if (nextPosition.i < 0 || nextPosition.j < 0 || nextPosition.i >= field.cols ||
nextPosition.j >= field.rows) {
next = WALL;
} else {
next = field.m[currentPosition.i + shiftList[currentDirection][0]]
[currentPosition.j + shiftList[currentDirection][1]];
}
if (next != NONE) {
char res[25];
currentSensor = next;
if (currentState == GO) {
currentState = STOP;
sprintf(res, "Stopped: %s", sensor_type_str[currentSensor]);
} else if (currentState == STOP) {
sprintf(res, "The %s was detected", sensor_type_str[currentSensor]);
}
publishRobotState();
publishMessage(res);
return false;
}
currentSensor = next;
return true;
}
void Board::printBoard(SDL_Window* window, SDL_Surface* screen) {
if (!screen || !window) return;
for (int x = 0; x < xFieldsNum; ++x) {
for (int y = 0; y < yFieldsNum; ++y) {
printField(window, screen, x, y);
}
}
}
void printResults(LPTICKETRESULTS ticketResults){
int i;
printf("Status= %d\n", ticketResults->status);
printTicketType(ticketResults->type, ticketResults->typeCnf);
for(i=0;i<NUMFIELDS_RESULTS;i++){
if(ticketResults->fieldsResults[i].name[0] != 0){
// printf("ticketResults->fieldsResults[i].name= %s\n", ticketResults->fieldsResults[i].name);
if(strcmp(ticketResults->fieldsResults[i].name, "NUMBERS") == 0) printField(&ticketResults->fieldsResults[i]);
if(strcmp(ticketResults->fieldsResults[i].name, "PLAYER") == 0) printField(&ticketResults->fieldsResults[i]);
if(strcmp(ticketResults->fieldsResults[i].name, "DATE") == 0) printField(&ticketResults->fieldsResults[i]);
// else printField(&ticketResults->fieldsResults[i]);
// if(strcmp(ticketResults->fieldsResults[i].name, "NUMBERS") == 0) printField(&ticketResults->fieldsResults[i]);
// if(strcmp(ticketResults->fieldsResults[i].name, "DATE") == 0) printField(&ticketResults->fieldsResults[i]);
}
}
}
OFile& OFile::printField(const std::string&name,double v) {
// When one tries to print -nan we print nan instead.
// The distinction between +nan and -nan is not well defined
// Always printing nan simplifies some regtest (special functions computed our of range).
if(std::isnan(v)) v=std::numeric_limits<double>::quiet_NaN();
sprintf(buffer_string.get(),fieldFmt.c_str(),v);
printField(name,buffer_string.get());
return *this;
}
extern void printFields (void)
{
unsigned int i;
if (Option.withListHeader)
printf ((Option.machinable? "%s\t%s\t%s\t%s\t%s\t%s\n": MAKE_FIELD_FMT(s)),
"#LETTER", "NAME", "ENABLED", "LANGUAGE", "XFMTCHAR", "DESCRIPTION");
for (i = 0; i < fieldDescUsed; i++)
printField (i);
}
void saveField()
{
std::ostringstream outs;
for (int i = 0 ; i < size ; ++i)
{
for (int j = 0 ; j < size ; ++j)
outs << field[i][j] << " ";
outs << "\n";
}
printField(outs.str());
}
main()
{
char field[M][N];
int loop, loop2;
for (loop = 0; loop < M; loop++)
for (loop2 = 0; loop2 < N; loop2++)
field[loop][loop2] = '1';
FieldGenerator(field);
printField(field);
}
int fieldToString(const Field *f, char *buf, unsigned int size)
{
freopen("mockoutput", "w", stdout);
printField(f);
fflush(stdout);
FILE *fp = fopen("mockoutput", "r");
if (!fp)
return -1;
int n = fread(buf, 1, size-1, fp);
buf[n] = 0;
fclose(fp);
return 0;
}
int drawMap(){
printGrid();
printPond();
printField();
steve(8,8);
printKey(40,10);
attron(COLOR_PAIR(5));
mvprintw(usry,usrx*2,"@");
attron(COLOR_PAIR(4));
mvprintw(0,40,"Player name: %s",pName);
mvprintw(1,40,"Health: %dHP",health);
mvprintw(2,40,"Hunger: %d", hunger);
mvprintw(4,40,"Description:");
return 0;
}
int main() {
int bombX, bombY;
int fieldHeight, fieldWidth;
char field[MAX_HEIGHT][MAX_WIDTH];
scanf("%d %d %d %d", &fieldHeight, &fieldWidth, &bombY, &bombX);
readField(field, fieldHeight, fieldWidth);
explodeTile(field, fieldHeight, fieldWidth, --bombY, --bombX);
printField(field, fieldHeight, fieldWidth);
return 0;
}
int main(int argc, char *argv[]) {
arrXLen=sizeof(workField[0])/sizeof(char);
arrYLen=(sizeof(workField)/sizeof(char))/arrXLen;
fillRow();
while(main) {
system("clear");
gen++;
printf("Generation %d\n",gen);
printField();
copyField();
calcField();
sleep(1);
}
}
void saveField(int player)
{
std::ostringstream outs;
for (int i = 0 ; i < size ; ++i)
{
for (int j = 0 ; j < size ; ++j)
{
outs << field[i][j] << " ";
}
outs << "\n";
}
outs << player << " " << row << " " << col << "\n";
outs << scores[0] << " " << scores[1] << "\n";
printField(outs.str());
}
/* Print */
void Class::print() {
printf("magic number: 0x%X\n", magic);
printf("major ver: 0x%02X (%d)\n", major_version, major_version);
printf("minor ver: 0x%02X (%d)\n", minor_version, minor_version);
printf("access flags: 0x%04X (%d)\n", access_flags, access_flags);
printf("class name: %s\n", get_cp_this_class());
printf("super name: %s\n", get_cp_super_class());
printf("\n");
printf("cp count: %d\n", cp_count);
print_cp();
printf("\n");
printf("fields count: %d\n", fields_count);
printField();
printf("\n");
printf("methods count: %d\n", methods_count);
printMethod();
}
void print_ClassFile(ClassFile* class_file_ptr){
printf("\n\nMagic: %.8x\n\n", class_file_ptr->magic);
printf("Minor Version: %.4x\n", class_file_ptr->minor_version);
printf("Major Version: %.4x\n\n", class_file_ptr->major_version);
printConstantPoolTable(class_file_ptr->constant_pool_count, class_file_ptr->constant_pool);
print_interface(class_file_ptr->interfaces, class_file_ptr->interfaces_count, class_file_ptr->constant_pool);
printField(class_file_ptr->constant_pool, class_file_ptr->fields, class_file_ptr->fields_count);
print_Methods(class_file_ptr, class_file_ptr->constant_pool);
print_attributes(class_file_ptr->attributes, class_file_ptr->attributes_count, class_file_ptr->constant_pool);
}
void printResponseCb(ZBExplicitRxResponse& rx, uintptr_t data) {
Print *p = (Print*)data;
p->println(F("ZBExplicitRxResponse received:"));
printField(p, F(" From: 0x"), rx.getRemoteAddress64());
printField(p, F(" From: 0x"), rx.getRemoteAddress16());
printField(p, F(" Receive options: 0x"), rx.getOption());
printField(p, F(" Src endpoint: 0x"), rx.getSrcEndpoint());
printField(p, F(" Dst endpoint: 0x"), rx.getDstEndpoint());
printField(p, F(" Cluster id: 0x"), rx.getClusterId());
printField(p, F(" Profile id: 0x"), rx.getProfileId());
if (rx.getDataLength() > 8)
p->print(" Payload:\r\n ");
else
p->print(" Payload: ");
printHex(*p, rx.getFrameData() + rx.getDataOffset(), rx.getDataLength(), F(" "), F("\r\n "), 8);
p->println();
}
int connectToHost() {
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
portno = atoi(PORT);
// Создаем сокет
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
printf("Error with opening socket\n");
exit(1);
}
server = gethostbyname(HOST);
if (server == NULL) {
printf("No such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
serv_addr.sin_port = htons(portno);
// коннектимся к серверу
if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
printf("Error with connect to server\n");
exit(1);
}
int err = read(sockfd, field, sizeof(int)*HEIGHT*WIDTH);
if (err < 0) {
printf("error with read from socket\n");
return;
}
printField();
return;
}
int main()
{
bool field[WIDTH][HEIGHT];
FILE *f;
if((f = fopen("in.txt", "r")) == NULL)
return -1;
for(int h = 0; h < HEIGHT; h++)
{
for(int w = 0; w < WIDTH; w++)
{
char c = getc(f);
field[w][h] = (c == '1' ? true : false);
}
getc(f);
}
int i;
for(i = 0; i < max_iterations; i++)
{
system("cls");
printField(field);
Sleep(DELAY);
if(!newField(field))
break;
cout << endl << endl;
}
setlocale(LC_ALL, "Russian");
if(i == max_iterations)
cout << "ƒостигнуто максимальное количество итераций." << endl;
else
cout << "ѕоле пришло в стационарное состо¤ние." << endl << endl << endl;
getchar();
return 0;
}
void printStruct(const std::string& parent, FILE * outputFileC, FILE * outputFileH, std::vector<StructDef *>& sd, int indent)
{
for(auto it = sd.begin(); it != sd.end(); ++ it)
{
std::string publicString, protectedString, constructString, destructString, packString, unpackString, sizeString;
fprintIndent(indent, outputFileH, "class %s: public ::ssu::Object\n", (*it)->name.c_str());
fprintIndent(indent, outputFileH, "{\n");
if(!(*it)->structList.empty() || !(*it)->enumList.empty())
{
fprintIndent(indent, outputFileH, "public:\n");
printEnum(outputFileH, (*it)->enumList, indent + indentSize);
printStruct(parent + (*it)->name + "::", outputFileC, outputFileH, (*it)->structList, indent + indentSize);
}
indent += indentSize;
bool needFlag = false;
int maxOrder = 0;
for(auto it2 = (*it)->fields.begin(); it2 != (*it)->fields.end(); ++ it2)
{
int oldOrder = it2->second->order;
if(it2->second->constraint == 2)
{
needFlag = true;
it2->second->order = maxOrder ++;
}
printField(outputFileH, publicString, protectedString, constructString, destructString, packString, unpackString, sizeString, it2->second->constraint, oldOrder, it2->second->order, it2->second->type, it2->second->tname, it2->second->name, alterDefVal(it2->second->type, it2->second->defVal), indent);
}
indent -= indentSize;
fprintIndent(indent, outputFileH, "public:\n");
if(!constructString.empty() || needFlag)
{
fprintIndent(indent + indentSize, outputFileH, "inline %s()", (*it)->name.c_str());
fputs(constructString.c_str(), outputFileH);
if(needFlag)
{
fputs("\n", outputFileH);
fprintIndent(indent + indentSize, outputFileH, "{ memset(_isSetFlag, 0, sizeof(_isSetFlag)); }\n\n");
}
else
fputs(" { }\n\n", outputFileH);
}
if(!destructString.empty())
{
fprintIndent(indent + indentSize, outputFileH, "virtual ~%s();\n", (*it)->name.c_str());
fprintf(outputFileC, "%s%s::~%s()\n", parent.c_str(), (*it)->name.c_str(), (*it)->name.c_str());
fputs("{\n", outputFileC);
fputs(destructString.c_str(), outputFileC);
fputs("}\n\n", outputFileC);
}
else
{
fprintIndent(indent + indentSize, outputFileH, "virtual ~%s() { }\n\n", (*it)->name.c_str());
}
fprintIndent(indent, outputFileH, "public:\n");
fprintIndent(indent + indentSize, outputFileH, "virtual unsigned char * packBuffer(unsigned char * buf);\n");
fprintIndent(indent + indentSize, outputFileH, "virtual bool unpackBuffer(const unsigned char *& buf, size_t& leftSize);\n");
fprintIndent(indent + indentSize, outputFileH, "virtual size_t size() const;\n\n");
if(!publicString.empty())
{
fprintIndent(indent, outputFileH, "public:\n");
fputs(publicString.c_str(), outputFileH);
}
if(!protectedString.empty())
{
fprintIndent(indent, outputFileH, "protected:\n");
fputs(protectedString.c_str(), outputFileH);
}
if(needFlag)
{
fprintf(outputFileH, "\n");
fprintIndent(indent + indentSize, outputFileH, "unsigned int _isSetFlag[%d];\n", (maxOrder + 31) / 32);
}
fprintf(outputFileH, "\n");
fprintIndent(indent, outputFileH, "};\n\n");
fprintIndent(0, outputFileC, "unsigned char * %s%s::packBuffer(unsigned char * buf)\n", parent.c_str(), (*it)->name.c_str());
fprintIndent(0, outputFileC, "{\n");
fputs(packString.c_str(), outputFileC);
fprintIndent(indentSize, outputFileC, "return buf;\n");
fprintIndent(0, outputFileC, "}\n\n");
fprintIndent(0, outputFileC, "bool %s%s::unpackBuffer(const unsigned char *& buf, size_t& leftSize)\n", parent.c_str(), (*it)->name.c_str());
fprintIndent(0, outputFileC, "{\n");
if(!unpackString.empty())
{
fprintIndent(indentSize, outputFileC, "unsigned int tag_; unsigned char type_;\n");
fprintIndent(indentSize, outputFileC, "while(leftSize > 0)\n");
fprintIndent(indentSize, outputFileC, "{\n");
fprintIndent(indentSize * 2, outputFileC, "if(!::ssu::Utils::unpackTag(buf, leftSize, tag_, type_)) return false;\n");
fprintIndent(indentSize * 2, outputFileC, "switch(tag_)\n");
fprintIndent(indentSize * 2, outputFileC, "{\n");
fputs(unpackString.c_str(), outputFileC);
fprintIndent(indentSize * 2, outputFileC, "default: break;\n");
fprintIndent(indentSize * 2, outputFileC, "}\n");
fprintIndent(indentSize, outputFileC, "}\n");
}
fprintIndent(indentSize, outputFileC, "return true;\n");
fprintIndent(0, outputFileC, "}\n\n");
fprintIndent(0, outputFileC, "size_t %s%s::size() const\n", parent.c_str(), (*it)->name.c_str());
fprintIndent(0, outputFileC, "{\n");
if(sizeString.empty())
fprintIndent(indentSize, outputFileC, "return 0;\n");
else
fprintIndent(indentSize, outputFileC, "return %s;\n", sizeString.c_str());
fprintIndent(0, outputFileC, "}\n\n");
}
}
struct omimRecord *omimRecordNext(struct lineFile *lf,
struct lm *lm, /* Local memory pool for this structure. */
struct dyString *dy, /* Scratch string to use. */
FILE *recFh,
FILE *fieldFh)
/* Read next record from file and parse it into omimRecord structure
* that is allocated in memory. */
{
char *line;
struct omimRecord *omimr;
char *chp;
int lineSize;
char *fieldType;
boolean recDone, fieldDone;
char *row[1];
boolean endOfFile = FALSE;
boolean endOfRec = FALSE;
boolean firstFieldDone = FALSE;
struct omimField *omimFd = NULL;
recDone = FALSE;
/* Parse record number and title lines. */
if (!lineFileRow(lf, row))
return NULL;
if (!sameString(row[0], "*RECORD*"))
{
errAbort("Expecting *RECORD* line %d of %s", lf->lineIx, lf->fileName);
}
lmAllocVar(lm, omimr);
omimr->startPos = lf->lineStart + lf->bufOffsetInFile;
if (!lineFileNext(lf, &line, &lineSize))
return NULL;
if (!sameString(line, "*FIELD* NO"))
errAbort("Expecting *FIELD* NO line %d of %s", lf->lineIx, lf->fileName);
if (!lineFileNextReal(lf, &line)) errAbort("%s ends in middle of a record", lf->fileName);
omimr->id = lmCloneString(lm, line);
if (!lineFileNextReal(lf, &line)) errAbort("%s ends in middle of a record", lf->fileName);
if (!sameString(line, "*FIELD* TI"))
errAbort("Expecting *FIELD* TI line %d of %s ---%s---", lf->lineIx, lf->fileName, line);
if (!lineFileNext(lf, &line, &lineSize)) errAbort("%s ends in middle of a record", lf->fileName);
if (!isdigit(*line))
{
omimr->type = *line;
}
else
{
omimr->type = '\0';
}
/* some records may not have gene symbol */
omimr->geneSymbol = "";
chp = strstr(line, ";");
if (chp != NULL)
{
*chp = '\0';
chp++;
if (*chp == ' ') chp++;
if (*chp != '\0') omimr->geneSymbol = cloneString(chp);
}
chp = strstr(line, omimr->id);
if (chp == NULL)
{
errAbort("Expecting TI line for record %s, %d of %s ---%s===", omimr->id, lf->lineIx,
lf->fileName, line);
}
chp = chp + strlen(omimr->id); chp++;
omimr->title = lmCloneString(lm, chp);
// !!! need to enhance it later to include startPos and length info.
fprintf(recFh, "%s\t%c\t%s\t%s\n", omimr->id, omimr->type, omimr->geneSymbol, omimr->title);
/* !!! temporarily skip lines before first FIELD after title */
/* further processing TBD */
while (strstr(line, "*FIELD*") == NULL)
{
lineFileNext(lf, &line, &lineSize);
}
lineFileReuse(lf);
/* process a field */
firstFieldDone = FALSE;
fieldDone = FALSE;
while (!recDone)
{
if (!lineFileNext(lf, &line, &lineSize))
{
endOfFile = TRUE;
}
/* "*THEEND*" signals the end of the OMIM text file */
if (sameWord(line, "*THEEND*")) endOfFile = TRUE;
if (!endOfFile && (strstr(line, "*RECORD*") != NULL))
{
endOfRec = TRUE;
}
/* handle termination of record here */
if (endOfFile || endOfRec)
{
lineFileReuse(lf);
recDone = TRUE;
if (firstFieldDone)
{
/* extra minus 1 to get rid of empty line at the end */
omimr ->endPos = lf->lineStart + lf->bufOffsetInFile - 1 - 1;
omimFd->endPos = lf->lineStart + lf->bufOffsetInFile - 1 - 1;
/* End of record or end of line also means end of a field. Print the field info */
printField(omimFd, fieldFh);
}
break;
}
chp = strstr(line, "*FIELD*");
if (chp != NULL)
{
fieldType = chp + strlen("*FIELD* ");
if (!firstFieldDone)
{
lmAllocVar(lm, omimFd);
firstFieldDone = TRUE;
/* do not print anything at the first "*FIELD*" line */
}
else
{
/* extra minus 1 to get rid of empty line at the end */
omimFd->endPos = lf->lineStart + lf->bufOffsetInFile - 1 - 1;
/* print previous field info */
printField(omimFd, fieldFh);
}
/* fill in current field info */
omimFd->omimId = cloneString(omimr->id);
omimFd->type = cloneString(fieldType);
omimFd->startPos = lf->lineEnd + lf->bufOffsetInFile;
}
}
if (endOfFile) return NULL;
return omimr;
}
void printField(chila::lib::misc::Printer &printer, unsigned tag, const char *name, const boost::optional<Type> &data)
{
if (data)
printField(printer, tag, name, *data);
}
