00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <string.h>
00004 #include <stdarg.h>
00005 #include <ctype.h>
00006 #include "iotools.h"
00007 #include "stacktrace.h"
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 void print_err(const char *emsg, const char *errfile, int errln, const char *errfunc, ...)
00026 {
00027 va_list params;
00028 fflush(stdout);
00029 fflush(stderr);
00030 fprintf(stderr, "\n\nError: ");
00031 va_start(params, errfunc);
00032 vfprintf(stderr, emsg, params);
00033 va_end(params);
00034 fprintf(stderr, "\n");
00035 fprintf(stderr, "detected in source file %s, line %d, function %s\n", errfile, errln, errfunc);
00036 stack_trace(stderr, 2);
00037 fflush(stderr);
00038 }
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056 void print_warning(const char *wmsg, const char *warnfile, int warnln, const char *warnfunc, ...)
00057 {
00058 va_list params;
00059 fflush(stdout);
00060 fflush(stderr);
00061 fprintf(stderr, "\n\nWarning: ");
00062 va_start(params, warnfunc);
00063 vfprintf(stderr, wmsg, params);
00064 va_end(params);
00065 fprintf(stderr,"\n");
00066 fprintf(stderr, "detected in file %s, line %d, function %s\n", warnfile, warnln, warnfunc);
00067 stack_trace(stderr, 2);
00068 fflush(stderr);
00069 }
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088 void par_print_err(int n,const char *emsg, const char *errfile, int errln, const char *errfunc, ...)
00089 {
00090 va_list params;
00091 fflush(stdout);
00092 fflush(stderr);
00093 fprintf(stderr, "\n\nError on processor %d:\n", n);
00094 va_start(params, errfunc);
00095 vfprintf(stderr, emsg, params);
00096 va_end(params);
00097 fprintf(stderr,"\n");
00098 fprintf(stderr, "detected in file %s, line %d, function %s\n", errfile, errln, errfunc);
00099 fflush(stderr);
00100 }
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 void par_print_err(int n,const char *pname, const char *emsg, const char *errfile, int errln, const char *errfunc, ...)
00121 {
00122 va_list params;
00123 fflush(stdout);
00124 fflush(stderr);
00125 fprintf(stderr, "\n\nError on processor %d (%s):\n", n, pname);
00126 va_start(params, errfunc);
00127 vfprintf(stderr, emsg, params);
00128 va_end(params);
00129 fprintf(stderr,"\n");
00130 fprintf(stderr, "detected in file %s, line %d, function %s\n", errfile, errln, errfunc);
00131 fflush(stderr);
00132 }
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 XFILE *xfopen(const char *name, const char *mode)
00152 {
00153 XFILE *ifile;
00154 if (strchr(mode,'w') || strchr(mode,'a'))
00155 {
00156 print_err("unsupported mode for opening of XFILE", __FILE__, __LINE__, __func__);
00157 abort();
00158 }
00159 if (name == NULL)
00160 {
00161 return NULL;
00162 }
00163 ifile = new XFILE;
00164 ifile->file = fopen(name, mode);
00165 ifile->line = 1;
00166 ifile->col = 1;
00167 ifile->lnfpos = 0;
00168 ifile->warning = 0;
00169
00170 ifile->fname = new char[strlen(name)+1];
00171 memcpy(ifile->fname, name, strlen(name)+1);
00172
00173 ifile->kwdmode = ignore;
00174 ifile->ignorecase = 0;
00175 ifile->set_maxlnsize(1024);
00176 ifile->maxlnover = 0;
00177
00178 ifile->index_created = 0;
00179 ifile->id_sec = -1;
00180 ifile->asect = NULL;
00181 ifile->num_sec = 0;
00182 ifile->sect = NULL;
00183
00184 if (ifile->file == NULL)
00185 {
00186 print_err("cannot open file %s for reading", __FILE__, __LINE__, __func__, name);
00187 delete ifile;
00188 ifile = NULL;
00189 }
00190 return ifile;
00191 }
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208 int xfclose(XFILE* &f)
00209 {
00210 int ret;
00211 if (f->maxlnover)
00212 {
00213 print_warning("maximum length of line exceeded at least one time\n"
00214 "input file: %s, the last oversized line=%ld, col=%ld",
00215 __FILE__, __LINE__, __func__, f->fname, f->maxlnover, f->give_maxlnsize());
00216 }
00217 if (f->file)
00218 ret = fclose(f->file);
00219
00220 delete f;
00221 f = NULL;
00222
00223 return ret;
00224 }
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244 char *locate_kwd(char *lnstr, const char *kwd, long ignorecase, long &noc)
00245 {
00246 char *ret;
00247 char *astr;
00248 size_t kwdl = strlen(kwd);
00249 size_t strl = strlen(lnstr);
00250 char *kwd_beg;
00251 noc = 0;
00252 ret = NULL;
00253 astr = lnstr;
00254 do
00255 {
00256 kwd_beg = strstr(astr, kwd, ignorecase);
00257 if (kwd_beg)
00258 {
00259
00260 if (kwd_beg-lnstr+kwdl < strl)
00261 {
00262 if ((isspace(kwd_beg[kwdl]) == 0) && (ispunct(kwd_beg[kwdl]) == 0))
00263
00264 {
00265 astr = kwd_beg+kwdl;
00266 kwd_beg = NULL;
00267 continue;
00268 }
00269 }
00270 if (kwd_beg-lnstr > 0)
00271 {
00272 if (isspace(kwd_beg[-1]) == 0)
00273
00274 {
00275 if (kwd_beg-lnstr+kwdl < strl)
00276 {
00277 astr = kwd_beg+kwdl;
00278 kwd_beg = NULL;
00279 continue;
00280 }
00281 else
00282 {
00283 kwd_beg = NULL;
00284 break;
00285 }
00286 }
00287 }
00288
00289 if (ret == NULL)
00290 ret = kwd_beg;
00291 noc++;
00292 if (kwd_beg-lnstr+kwdl < strl)
00293
00294
00295 {
00296 astr = kwd_beg+kwdl;
00297 kwd_beg = NULL;
00298 }
00299 else
00300
00301 break;
00302 }
00303 else
00304
00305 break;
00306 } while(1);
00307
00308 return ret;
00309 }
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333 long xfdetect_sect(XFILE* f, const kwdset &kwdb, const kwdset &kwde)
00334 {
00335 char *lnstr;
00336 long i, j, l;
00337 long n = kwdb.n;
00338 long num_sec;
00339 long line;
00340
00341 long lnfpos = 0;
00342 long lnfpos_p = -1;
00343 size_t kwdl;
00344 long noc;
00345 char *kwd_beg;
00346 char *kwd_end;
00347 xfsection **sect;
00348 xfsection *tsect;
00349
00350 switch (f->kwdmode)
00351 {
00352 case sect_mode_seq:
00353 case sect_mode_full:
00354 case sect_mode_ignore:
00355 case sect_mode_fwd:
00356 break;
00357 default:
00358 return 0;
00359 }
00360
00361 lnstr = f->lnstr;
00362 sect = new xfsection*[n];
00363 memset(sect, 0, sizeof(*sect)*n);
00364
00365 fseek(f->file, 0, SEEK_SET);
00366 line = 1;
00367 if (kwdb.n != kwde.n)
00368 {
00369 print_err("Number of keywords for beginning of sections is not the same\n"
00370 " as number of keywords for end of sections\n", __FILE__, __LINE__, __func__);
00371 abort();
00372 }
00373 do
00374 {
00375 memset(lnstr, 0, sizeof(*lnstr)*f->give_maxlnsize()+1);
00376 fscanf(f->file, "%[^\n]",lnstr);
00377 clearcomments(lnstr);
00378
00379 l = strlen(lnstr);
00380 if (l > 0)
00381 {
00382 if (lnstr[l-1] == '\r')
00383 lnstr[l-1] = '\0';
00384 }
00385 if (strlen(lnstr) == 0)
00386 {
00387 fscanf(f->file, "%1[\n]", lnstr);
00388 line++;
00389
00390 lnfpos_p = lnfpos;
00391 lnfpos = ftell(f->file);
00392 continue;
00393 }
00394 for (i=0; i<n; i++)
00395 {
00396
00397 kwdl = strlen(kwdb.set[i].alias);
00398 kwd_beg = locate_kwd(lnstr, kwdb.set[i].alias, f->ignorecase, noc);
00399 if (kwd_beg)
00400 {
00401 if ((sect[i] == NULL) && (noc < 2))
00402 {
00403 tsect = new xfsection;
00404 tsect->beg_secpos = lnfpos + kwd_beg - lnstr + kwdl;
00405 tsect->beg_secln = line;
00406 tsect->beg_seccol = kwd_beg - lnstr + kwdl + 1;
00407 tsect->name.id = kwdb.set[i].id;
00408
00409
00410 tsect->name.alias = kwdb.set[i].alias;
00411 tsect->end_secpos = -1;
00412 sect[i] = tsect;
00413 }
00414 else
00415 {
00416 if (sect[i] == NULL)
00417 print_err("Multiple occurence of keyword '%s' on line %ld\n", __FILE__, __LINE__, __func__,
00418 kwdb.set[i].alias, line);
00419 else
00420 print_err("Multiple occurence of keyword '%s' (line %ld and line %ld)\n",
00421 __FILE__, __LINE__, __func__, kwdb.set[i].alias, sect[i]->beg_secln, line);
00422 abort();
00423 }
00424 }
00425
00426
00427 kwdl = strlen(kwde.set[i].alias);
00428 kwd_end = locate_kwd(lnstr, kwde.set[i].alias, f->ignorecase, noc);
00429 if (kwd_end)
00430
00431 {
00432 if (sect[i] == NULL)
00433
00434 {
00435 print_err("Keyword for end of section '%s' (line %ld) precedes keyword for beginning of section\n",
00436 __FILE__, __LINE__, __func__, kwde.set[i].alias, line);
00437 abort();
00438 }
00439 if ((noc > 1) || (sect[i]->end_secpos >= 0))
00440 {
00441 if (sect[i]->end_secpos >= 0)
00442 print_err("Multiple occurence of keyword '%s' on line %ld\n",
00443 __FILE__, __LINE__, __func__, kwde.set[i].alias, line);
00444 else
00445 print_err("Multiple occurence of keyword '%s' (line %ld and line %ld)\n",
00446 __FILE__, __LINE__, __func__, kwde.set[i].alias, sect[i]->end_secln, line);
00447
00448 abort();
00449 }
00450 sect[i]->end_secpos = lnfpos + kwd_end - lnstr - 1;
00451 if ((kwd_end - lnstr) == 0)
00452 {
00453
00454 sect[i]->end_secln = line-1;
00455 sect[i]->end_seccol = lnfpos-1-lnfpos_p+1;
00456 }
00457 else
00458 {
00459 sect[i]->end_secln = line;
00460 sect[i]->end_seccol = kwd_end - lnstr + 1;
00461 }
00462 }
00463 }
00464 } while (!feof(f->file));
00465
00466
00467 for(i=0, num_sec=0; i<n; i++)
00468 {
00469 if (sect[i])
00470 num_sec++;
00471 }
00472 if (num_sec)
00473 {
00474
00475 f->sect = new xfsection[num_sec];
00476 j = 0;
00477 for(i=0; i<n; i++)
00478 {
00479 if (sect[i])
00480 {
00481 if (sect[i]->end_secpos < 0)
00482 {
00483 print_err("Beginning keyword '%s' was found (line %ld) but end keyword '%s' was not found\n",
00484 __FILE__, __LINE__, __func__, sect[i]->name.alias, sect[i]->beg_secln, kwde.set[i].alias);
00485 abort();
00486 }
00487 f->sect[j].beg_secpos = sect[i]->beg_secpos;
00488 f->sect[j].end_secpos = sect[i]->end_secpos;
00489 f->sect[j].beg_secln = sect[i]->beg_secln;
00490 f->sect[j].end_secln = sect[i]->end_secln;
00491 f->sect[j].beg_seccol = sect[i]->beg_seccol;
00492 f->sect[j].end_seccol = sect[i]->end_seccol;
00493 f->sect[j].name = sect[i]->name;
00494 j++;
00495 }
00496 delete sect[i];
00497 }
00498 f->index_created = 1;
00499 f->id_sec = 0;
00500 f->asect = &f->sect[0];
00501 f->num_sec = num_sec;
00502 }
00503 delete [] sect;
00504
00505 fseek(f->file, f->lnfpos, SEEK_SET);
00506 return num_sec;
00507 }
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523 void xf_resetsec(XFILE *f)
00524 {
00525 char rfmt[20];
00526 int fbr;
00527 long l, errbrk;
00528
00529 if ((f->index_created == 0) || (f->id_sec < 0) || (f->id_sec > f->num_sec-1))
00530 {
00531 if (f->index_created == 0)
00532 print_err("Error - index of sections in file %s was not created\n", __FILE__, __LINE__, __func__, f->fname);
00533 if ((f->id_sec < 0) || (f->id_sec > f->num_sec-1))
00534 print_err("Error - index %ld of section in file %s is out of range (0, %ld)\n",
00535 __FILE__, __LINE__, __func__, f->id_sec, f->fname, f->num_sec-1);
00536 abort();
00537 }
00538 fseek(f->file, f->asect->beg_secpos, SEEK_SET);
00539 f->line = f->asect->beg_secln;
00540 f->col = f->asect->beg_seccol;
00541 f->lnfpos = f->asect->beg_secpos-f->col+1;
00542
00543
00544 fseek(f->file, f->lnfpos, SEEK_SET);
00545 sprintf(rfmt, "%%%ld[^\n]%%n", f->give_maxlnsize());
00546 fscanf(f->file, rfmt, f->lnstr, &fbr);
00547 errbrk = check_maxlnsize(f, fbr);
00548 if (errbrk)
00549 abort();
00550
00551 cut_str_sec(f, f->lnstr);
00552
00553 l = strlen(f->lnstr);
00554 if (l > 0)
00555 {
00556 if (f->lnstr[l-1] == '\r')
00557 f->lnstr[l-1] = '\0';
00558 }
00559 clearcomments(f->lnstr);
00560 return;
00561 }
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579 long xf_setsec(XFILE *f, enumstr sec_alias)
00580 {
00581 long i, id = -1;
00582
00583 if (f->index_created == 0)
00584
00585 return 2;
00586
00587 for (i = 0; i < f->num_sec; i++)
00588 {
00589 if (strstr(f->sect[i].name.alias, sec_alias.alias) &&
00590 f->sect[i].name.id == sec_alias.id)
00591 {
00592
00593 id = i;
00594 break;
00595 }
00596 }
00597 if (id < 0)
00598
00599 return 1;
00600
00601
00602 f->id_sec = id;
00603 f->asect = &f->sect[id];
00604 xf_resetsec(f);
00605 return 0;
00606 }
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623 long xf_setsec(XFILE *f, long sec_id)
00624 {
00625 if (f->index_created == 0)
00626
00627 return 2;
00628
00629 if ((sec_id < 0) || (sec_id > f->num_sec))
00630
00631 return 1;
00632
00633
00634 f->id_sec = sec_id;
00635 f->asect = &f->sect[sec_id];
00636 xf_resetsec(f);
00637 return 0;
00638 }
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654 void xf_copysec(XFILE *f, FILE *out)
00655 {
00656 char *str;
00657 char fmt[50];
00658 long pos;
00659 int size;
00660 if (f->asect == NULL)
00661 {
00662 print_err("cannot determine the actual file section", __FILE__, __LINE__, __func__);
00663 abort();
00664 }
00665
00666 pos = ftell(f->file);
00667 if ((pos < f->asect->beg_secpos) || (pos > f->asect->end_secpos))
00668 {
00669
00670 print_err("cannot determine position in the actual file section", __FILE__, __LINE__, __func__);
00671 abort();
00672 }
00673
00674 str = new char[1024];
00675 memset(str, 0, sizeof(*str)*1024);
00676
00677 while (pos+1024 < f->asect->end_secpos)
00678 {
00679 pos += 1024;
00680 fscanf(f->file, "%1024c", str);
00681 fprintf(out, "%.1024s", str);
00682 }
00683
00684
00685
00686 size = int(f->asect->end_secpos - pos + 1);
00687
00688 sprintf(fmt, "%%%dc", size);
00689 fscanf(f->file, fmt, str);
00690 fprintf(out, "%.*s", size, str);
00691 delete [] str;
00692 }
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729 int xfscanf(XFILE *in, char *fmt, ...)
00730 {
00731 long nvar;
00732 char *types;
00733 char **ptypes;
00734 long idt;
00735 char *subfmt;
00736 unsigned int br;
00737 int tbr;
00738 va_list params;
00739 void *apar;
00740 char *lnstr;
00741 char *aptr;
00742 long errbrk;
00743 long read;
00744 long ret;
00745 long war;
00746 long readkwdval;
00747 kwdset *akwdset;
00748 long l;
00749 long start_pos;
00750 char *akwd;
00751 long aline;
00752 long acol;
00753 char rfmt[20];
00754 int fbr;
00755 int width;
00756 long w;
00757 char *afmt;
00758 char *aux;
00759 char *auxapar;
00760 long nskip;
00761 long optkwd;
00762 long skip_kwdval;
00763 long repeat;
00764 long multiline;
00765 long brmln;
00766
00767
00768 nvar = checkfmt(fmt);
00769 if (nvar == 0)
00770 return 0;
00771
00772 types = new char[nvar];
00773 ptypes = new char*[nvar];
00774 subfmt = new char[strlen(fmt)+5];
00775 lnstr = in->lnstr;
00776 aptr = lnstr + in->col - 1;
00777
00778
00779
00780 gettypes(fmt, types, ptypes, nvar);
00781
00782 va_start(params, fmt);
00783 idt = 0;
00784 errbrk = 0;
00785 readkwdval = 0;
00786 if ((in->line == 1) && (in->col == 1))
00787 read = 1;
00788 else
00789 read = 0;
00790 width=0;
00791 nskip = 0;
00792 skip_kwdval = 0;
00793 optkwd = 0;
00794 multiline = 0;
00795 brmln = 0;
00796 br = 0;
00797 tbr = 0;
00798 start_pos = ftell(in->file);
00799
00800
00801 getsubfmt(ptypes[idt], subfmt,1);
00802 if ((check_asterisk(subfmt)==1) || (types[idt] == ' '))
00803
00804 apar = NULL;
00805 else
00806 {
00807
00808 apar = va_arg(params, void*);
00809 if (types[idt] == '[')
00810 *((char*)apar) = '\0';
00811 }
00812 auxapar = (char*)apar;
00813
00814 do
00815 {
00816 if (read && readkwdval && (in->kwdmode == line_mode))
00817 {
00818
00819
00820 print_err("cannot read value of keyword '%s' (fmt '%s', par id=%ld)\n"
00821 "input file: %s, line=%ld, col=%ld", __FILE__, __LINE__, __func__,
00822 akwd, fmt, idt+1, in->fname, in->line, in->col);
00823 abort();
00824 }
00825 if (read && readkwdval && ((in->kwdmode == sect_mode_fwd) || (in->kwdmode == sect_mode_seq)) &&
00826 (in->line == in->asect->end_secln))
00827 {
00828
00829
00830 print_err("cannot read value of keyword '%s' (fmt '%s', par id=%ld)\n"
00831 "input file: %s, line=%ld, col=%ld", __FILE__, __LINE__, __func__,
00832 akwd, fmt, idt+1, in->fname, in->line, in->col);
00833 abort();
00834 }
00835 if (read)
00836 {
00837 memset(lnstr, 0, sizeof(*lnstr)*in->give_maxlnsize()+1);
00838 checkfeof(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00839 checkeos(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00840
00841 if (feof(in->file))
00842 {
00843
00844
00845
00846 lnstr[0] = '\0';
00847 }
00848 else
00849 {
00850 sprintf(rfmt, "%%%ld[^\n]%%n", in->give_maxlnsize()-(in->col-1));
00851 fbr = 0;
00852 fscanf(in->file, rfmt, lnstr, &fbr);
00853 errbrk = check_maxlnsize(in, fbr);
00854 if (errbrk)
00855 break;
00856
00857 cut_str_sec(in, lnstr);
00858
00859 l = strlen(lnstr);
00860 if (l > 0)
00861 {
00862 if (lnstr[l-1] == '\r')
00863 lnstr[l-1] = '\0';
00864 }
00865 clearcomments(lnstr);
00866 }
00867 aptr = lnstr;
00868 read = 0;
00869 }
00870 if (strlen(aptr) == 0)
00871 {
00872 if ((types[idt] != 'a') || a_fmt_skips_whitespaces(ptypes[idt]) || multiline)
00873
00874 {
00875 checkfeof(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00876 checkeos(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00877 if (types[idt] == '[')
00878 {
00879 if (check_newline_fmt(ptypes[idt]))
00880 {
00881 if (apar != NULL)
00882 {
00883 *((char*)apar) = '\n';
00884 apar = (char*)apar + 1;
00885 *((char*)apar) = '\0';
00886 }
00887 }
00888 else
00889 {
00890 idt++;
00891 continue;
00892 }
00893 }
00894 if (feof(in->file))
00895 {
00896
00897
00898
00899
00900 }
00901 else
00902 {
00903 fscanf(in->file, "%1[\n]", lnstr);
00904 in->line++;
00905 in->col=1;
00906 in->lnfpos = ftell(in->file);
00907 read = 1;
00908 continue;
00909 }
00910 }
00911 }
00912
00913 if (strchr("efgdikmopsux",types[idt]) && isemptystr(aptr, " \t\n\r"))
00914 {
00915 checkfeof(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00916 checkeos(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00917 if (feof(in->file))
00918 {
00919
00920
00921
00922 }
00923 else
00924 {
00925 fscanf(in->file, "%1[\n]", lnstr);
00926 in->line++;
00927 in->col=1;
00928 in->lnfpos = ftell(in->file);
00929 read = 1;
00930 continue;
00931 }
00932 }
00933
00934 if ((types[idt] == 'a') && (ptypes[idt][1] == ' ') && isemptystr(aptr, "\r"))
00935 {
00936 checkfeof(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00937 checkeos(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
00938 fscanf(in->file, "%1[\n]", lnstr);
00939 in->line++;
00940 in->col=1;
00941 in->lnfpos = ftell(in->file);
00942 read = 1;
00943 continue;
00944 }
00945 ret = 0;
00946 war = 0;
00947
00948 switch (tolower(types[idt]))
00949 {
00950 case 'a':
00951 l = strlen(aptr);
00952 if (multiline == 0)
00953 {
00954 ret = sscanf(ptypes[idt]+1, "%d", &width);
00955
00956 if (ret == 0)
00957 w = l;
00958 }
00959 else
00960 {
00961 if (width > 0)
00962 {
00963 if (br+l <= width)
00964 w = l;
00965 else
00966 {
00967 print_err("maximum length of the scanned multiline string exceeded\n"
00968 "reading of %%a cannot be continued correctly (fmt '%s', par id=%ld)\n"
00969 "input file: %s, line=%ld, col=%ld",
00970 __FILE__, __LINE__, __func__, fmt, idt+1, in->fname, in->line, in->col);
00971 errbrk = 1;
00972 readkwdval = 0;
00973 akwd = NULL;
00974 break;
00975 }
00976 }
00977 else
00978 w = l;
00979 }
00980 if (apar != NULL)
00981 {
00982 memcpy((char*)(apar)+brmln, aptr, sizeof(char)*w);
00983 ((char *)apar)[brmln+w] = '\0';
00984 multiline = detect_multln((char*)(apar));
00985 }
00986 else
00987 multiline = detect_multln(aptr);
00988
00989 brmln += w;
00990 br = w;
00991 if (in->line == in->maxlnover)
00992 {
00993 print_err("maximum length of line exceeded\n"
00994 "reading of %%a cannot be continued correctly (fmt '%s', par id=%ld)\n"
00995 "input file: %s, line=%ld, col=%ld",
00996 __FILE__, __LINE__, __func__, fmt, idt+1, in->fname, in->line, in->col);
00997 errbrk = 1;
00998 }
00999 else
01000 errbrk = 0;
01001 readkwdval = 0;
01002 akwd = NULL;
01003 break;
01004 case 'k':
01005
01006
01007 aline = in->line;
01008 acol = in->col;
01009 ret = getkwd(in, lnstr, aptr, (char *)apar, br);
01010 optkwd = (ptypes[idt][1] == '+');
01011 if ((ret && (optkwd == 0)) ||
01012 ((ret > 1) && (optkwd)))
01013 {
01014
01015 switch (ret)
01016 {
01017 case 1:
01018 print_err("cannot read keyword '%s' (fmt '%s', par id=%ld)\n"
01019 "input file: %s, line=%ld, col=%ld",
01020 __FILE__, __LINE__, __func__, (char *)apar, fmt, idt+1, in->fname, aline, acol);
01021 break;
01022 case 2:
01023 print_err("multiple occurence of keyword '%s' on line (fmt '%s', par id=%ld)\n"
01024 "input file: %s, line=%ld, col=%ld",
01025 __FILE__, __LINE__, __func__, (char *)apar, fmt, idt+1, in->fname, aline, acol);
01026 break;
01027 case 3:
01028 print_err("zero length of keyword '%s' (fmt '%s', par id=%ld)\n"
01029 "input file: %s, line=%ld, col=%ld",
01030 __FILE__, __LINE__, __func__, (char *)apar, fmt, idt+1, in->fname, aline, acol);
01031 break;
01032
01033 }
01034 akwd = NULL;
01035 errbrk = 1;
01036 }
01037 else
01038 {
01039 if (ret && optkwd)
01040 {
01041 akwd = NULL;
01042 skip_kwdval = 1;
01043 nskip++;
01044
01045 }
01046 else
01047 {
01048
01049 readkwdval = 1;
01050 akwd = (char *)apar;
01051 }
01052 }
01053 break;
01054 case 'm':
01055 akwdset = (kwdset *)apar;
01056
01057 apar = va_arg(params, void*);
01058 ret = getenum(aptr, akwdset,(int *)apar, br, war, in->kwdmode, in->ignorecase);
01059 errbrk = checkenumerr(in, ret, 1, war, akwdset, fmt, subfmt, idt,
01060 ptypes[idt], __FILE__, __LINE__, __func__);
01061 readkwdval = 0;
01062 akwd = NULL;
01063 break;
01064 case 'f':
01065 case 'e':
01066 case 'g':
01067 war = checkreal(aptr);
01068 if (apar == NULL)
01069 ret = sscanf(aptr, subfmt,&br);
01070 else
01071 {
01072 ret = sscanf(aptr, subfmt,apar,&br);
01073 errbrk = checkscanferr(in, ret, 1, war, "cannot read real number",
01074 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01075 }
01076 readkwdval = 0;
01077 akwd = NULL;
01078 break;
01079 case 'd':
01080 case 'i':
01081 war = checkint(aptr);
01082 if (apar == NULL)
01083 ret = sscanf(aptr, subfmt,&br);
01084 else
01085 {
01086 ret = sscanf(aptr, subfmt,apar,&br);
01087 errbrk = checkscanferr(in, ret, 1, war, "cannot read integer number",
01088 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01089 }
01090 readkwdval = 0;
01091 akwd = NULL;
01092 break;
01093 case 'u':
01094 war = checkuint(aptr);
01095 if (apar == NULL)
01096 ret = sscanf(aptr, subfmt,&br);
01097 else
01098 {
01099 ret = sscanf(aptr, subfmt,apar,&br);
01100 errbrk = checkscanferr(in, ret, 1, war, "cannot read unsigned integer number",
01101 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01102 }
01103 readkwdval = 0;
01104 akwd = NULL;
01105 break;
01106 case 'o':
01107 war = checkouint(aptr);
01108 if (apar == NULL)
01109 ret = sscanf(aptr, subfmt,&br);
01110 else
01111 {
01112 ret = sscanf(aptr, subfmt,apar,&br);
01113 errbrk = checkscanferr(in, ret, 1, war, "cannot read unsigned integer number",
01114 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01115 }
01116 readkwdval = 0;
01117 akwd = NULL;
01118 break;
01119 case 'x':
01120 case 'p':
01121 war = checkxuint(aptr);
01122 if (apar == NULL)
01123 ret = sscanf(aptr, subfmt,&br);
01124 else
01125 {
01126 ret = sscanf(aptr, subfmt,apar,&br);
01127 errbrk = checkscanferr(in, ret, 1, war, "cannot read unsigned integer number",
01128 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01129 }
01130 readkwdval = 0;
01131 akwd = NULL;
01132 break;
01133 case 'n':
01134 *((int *)apar) = tbr;
01135 errbrk = 0;
01136 break;
01137 case ' ':
01138 if (idt < nvar-1)
01139 afmt = proc_ord_fmt(in, ptypes[idt], ptypes[idt+1], lnstr, aptr);
01140 else
01141 afmt = proc_ord_fmt(in, ptypes[idt], NULL, lnstr, aptr);
01142 if (afmt)
01143 {
01144 aux = new char[strlen(fmt)];
01145 if (idt<nvar-1)
01146 strncpy(aux, afmt, ptypes[idt+1]-afmt);
01147 else
01148 strcpy(aux, afmt);
01149 aux[strlen(aux)] = '\0';
01150 print_err("cannot read required format string '%s'\n"
01151 "(format '%s', subformat '%s', parameter id=%ld)\n"
01152 "input file: %s, line=%ld, column=%ld", __FILE__, __LINE__, __func__,
01153 aux, fmt, subfmt, idt+1, in->fname, in->line, in->col);
01154 delete [] aux;
01155 errbrk = 1;
01156 }
01157 else
01158 errbrk = 0;
01159 br = 0;
01160 readkwdval = 0;
01161 akwd = NULL;
01162 break;
01163 default:
01164 if (apar == NULL)
01165 ret = sscanf(aptr, subfmt, &br);
01166 else
01167 {
01168 ret = sscanf(aptr, subfmt, apar, &br);
01169 if (apar == auxapar)
01170 errbrk = checkscanferr(in, ret, 1, 0, "cannot read required format",
01171 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01172 }
01173 readkwdval = 0;
01174 akwd = NULL;
01175 }
01176 if (errbrk)
01177 break;
01178 else
01179 {
01180
01181
01182 if (((in->kwdmode == sect_mode_seq) || (in->kwdmode == sect_mode_fwd) || (in->kwdmode == sect_mode_full)) &&
01183 (readkwdval == 1))
01184 tbr = in->lnfpos - in->asect->beg_secpos + in->col - 1;
01185 else
01186 {
01187 in->col += br;
01188 aptr += br;
01189 tbr = in->lnfpos - start_pos + in->col - 1;
01190 }
01191
01192
01193
01194 if ((types[idt] == '[') && (apar == NULL) && (auxapar == apar) && (br == 0))
01195 {
01196 checkfeof(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
01197 checkeos(in, fmt, idt, ptypes[idt], subfmt, types, apar, __FILE__, __LINE__, __func__);
01198 errbrk = checkscanferr(in, 0, 1, 0, "cannot read required format",
01199 fmt, subfmt, idt, ptypes[idt], __FILE__, __LINE__, __func__);
01200 break;
01201 }
01202
01203 if (multiline)
01204 continue;
01205
01206
01207 if ((types[idt] == '[') && (*aptr == '\0') && check_newline_fmt(ptypes[idt]))
01208 {
01209 if (apar)
01210 apar = (char*)(apar) + br;
01211 else
01212 auxapar += br;
01213 if (check_feof_eos(in) == 0)
01214 continue;
01215 }
01216
01217
01218 if (types[idt] != ' ')
01219 {
01220 if (idt < nvar-1)
01221 afmt = proc_ord_fmt(in, ptypes[idt], ptypes[idt+1], lnstr, aptr);
01222 else
01223 afmt = proc_ord_fmt(in, ptypes[idt], NULL, lnstr, aptr);
01224 if (afmt)
01225 {
01226 aux = new char[strlen(fmt)];
01227 if (idt<nvar-1)
01228 strncpy(aux, afmt, ptypes[idt+1]-afmt);
01229 else
01230 strcpy(aux, afmt);
01231 aux[strlen(aux)] = '\0';
01232 print_err("cannot read required format string '%s'\n"
01233 "(format '%s', subformat '%s', parameter id=%ld)\n"
01234 "input file: %s, line=%ld, column=%ld", __FILE__, __LINE__, __func__,
01235 aux, fmt, subfmt, idt+1, in->fname, in->line, in->col);
01236 delete [] aux;
01237 errbrk = 1;
01238 break;
01239 }
01240 }
01241
01242
01243 brmln = 0;
01244 width = 0;
01245 multiline = 0;
01246
01247 do
01248 {
01249 repeat = 0;
01250 idt++;
01251 if (idt < nvar)
01252 {
01253
01254
01255 getsubfmt(ptypes[idt], subfmt,1);
01256 if ((check_asterisk(subfmt)==1) || (types[idt] == ' '))
01257
01258 apar = NULL;
01259 else
01260 {
01261
01262 apar = va_arg(params, void*);
01263 if (types[idt] == '[')
01264 *((char*)apar) = '\0';
01265 }
01266
01267 auxapar = (char *)apar;
01268
01269 if (skip_kwdval)
01270 {
01271 nskip++;
01272 skip_kwdval = 0;
01273 repeat = 1;
01274 }
01275 }
01276 } while (repeat);
01277
01278 }
01279 } while (idt < nvar);
01280 va_end(params);
01281 ret = idt;
01282 if (nskip)
01283 ret -= nskip;
01284
01285 if (types[0] == ' ')
01286 ret--;
01287 delete [] types;
01288 delete [] ptypes;
01289 delete [] subfmt;
01290 if (errbrk)
01291 abort();
01292
01293 return ret;
01294 }
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322 int xfprintf(XFILE *out, char *fmt, ...)
01323 {
01324 long nvar;
01325 char *types;
01326 char **ptypes;
01327 long idt;
01328 char *subfmt;
01329 char *pconv;
01330 unsigned int tbw;
01331 unsigned int bw;
01332 long optkwd;
01333 kwdset *akwdset;
01334 va_list params;
01335 void *apar;
01336 void *apar2;
01337
01338 char ct;
01339 char aux;
01340
01341
01342 nvar = checkfmt(fmt);
01343 if (nvar == 0)
01344 return 0;
01345
01346 types = new char[nvar];
01347 ptypes = new char*[nvar];
01348 subfmt = new char[strlen(fmt)+5];
01349
01350
01351
01352 gettypes(fmt, types, ptypes, nvar);
01353
01354 va_start(params, fmt);
01355 idt = 0L;
01356 optkwd = 0L;
01357
01358
01359
01360 getsubfmt(ptypes[idt], subfmt, &pconv, 0);
01361 if (types[idt] == ' ')
01362 {
01363
01364 apar = NULL;
01365 }
01366 else
01367 {
01368
01369 apar = va_arg(params, void*);
01370 }
01371
01372 ct = tolower(types[idt]);
01373 do
01374 {
01375 switch (ct)
01376 {
01377 case 'a':
01378 case '[':
01379 if (pconv[0] == '[')
01380 pconv[1] = '\0';
01381 pconv[0] = 's';
01382 bw = fprintf(out->file, subfmt, apar);
01383 tbw += bw;
01384 out->col += bw;
01385 break;
01386
01387
01388 case 's':
01389 aux = *(pconv+1);
01390 pconv[1] = '\0';
01391 bw = fprintf(out->file, subfmt, apar);
01392 tbw += bw;
01393 out->col += bw;
01394 pconv[1] = aux;
01395 bw = proc_new_ln_fmt(out, pconv+1);
01396 tbw += bw;
01397 break;
01398
01399
01400 case 'k':
01401 apar2 = NULL;
01402 optkwd = (ptypes[idt][1] == '+');
01403 if (optkwd)
01404 apar2 = va_arg(params, void*);
01405 if (optkwd && (apar2 == NULL))
01406 break;
01407 else
01408 {
01409 pconv[0] = 's';
01410 if (out->kwdmode > ignore)
01411 {
01412 bw = fprintf(out->file, subfmt, apar);
01413 tbw += bw;
01414 out->col += bw;
01415 }
01416 }
01417 break;
01418
01419
01420 case 'm':
01421 akwdset = (kwdset *)apar;
01422
01423 apar = va_arg(params, void*);
01424 if (akwdset->check_int(*((int*)apar)))
01425 {
01426 print_err("integer value %d is not defined in the given kwdset", __FILE__, __LINE__, __func__, *((int*)apar));
01427 abort();
01428 }
01429
01430 if (out->kwdmode > ignore)
01431 {
01432 pconv[0] = 's';
01433 bw = fprintf(out->file, subfmt, akwdset->get_str(*((int*)apar)));
01434 out->col += bw;
01435 tbw += bw;
01436 }
01437 else
01438 {
01439 pconv[0] = 'd';
01440 bw = fprintf(out->file, subfmt, *((int*)apar));
01441 out->col += bw;
01442 tbw += bw;
01443 }
01444 break;
01445
01446
01447 case 'f':
01448 case 'e':
01449 case 'g':
01450 if (get_modif(subfmt, pconv, "ll", 2))
01451 {
01452 bw = fprintf(out->file, subfmt, *((long double*)apar));
01453 tbw += bw;
01454 out->col += bw;
01455 break;
01456 }
01457 if (get_modif(subfmt, pconv, "L", 1))
01458 {
01459 bw = fprintf(out->file, subfmt, *((long double*)apar));
01460 tbw += bw;
01461 out->col += bw;
01462 break;
01463 }
01464 if (get_modif(subfmt, pconv, "l", 1))
01465 {
01466 bw = fprintf(out->file, subfmt, *((double*)apar));
01467 tbw += bw;
01468 out->col += bw;
01469 break;
01470 }
01471
01472 bw = fprintf(out->file, subfmt, *((float*)apar));
01473 tbw += bw;
01474 out->col += bw;
01475 break;
01476
01477
01478 case 'd':
01479 case 'i':
01480 if (get_modif(subfmt, pconv, "ll", 2))
01481 {
01482 bw = fprintf(out->file, subfmt, *((long long int*)apar));
01483 tbw += bw;
01484 out->col += bw;
01485 break;
01486 }
01487 if (get_modif(subfmt, pconv, "l", 1))
01488 {
01489 bw = fprintf(out->file, subfmt, *((long int*)apar));
01490 tbw += bw;
01491 out->col += bw;
01492 break;
01493 }
01494 if (get_modif(subfmt, pconv, "hh", 2))
01495 {
01496 bw = fprintf(out->file, subfmt, *((signed char*)apar));
01497 tbw += bw;
01498 out->col += bw;
01499 break;
01500 }
01501 if (get_modif(subfmt, pconv, "h", 1))
01502 {
01503 bw = fprintf(out->file, subfmt, *((short int*)apar));
01504 tbw += bw;
01505 out->col += bw;
01506 break;
01507 }
01508
01509 bw = fprintf(out->file, subfmt, *((int*)apar));
01510 tbw += bw;
01511 out->col += bw;
01512 break;
01513
01514
01515 case 'u':
01516 case 'o':
01517 case 'x':
01518 if (get_modif(subfmt, pconv, "ll", 2))
01519 {
01520 bw = fprintf(out->file, subfmt, *((unsigned long long int*)apar));
01521 tbw += bw;
01522 out->col += bw;
01523 break;
01524 }
01525 if (get_modif(subfmt, pconv, "l", 1))
01526 {
01527 bw = fprintf(out->file, subfmt, *((unsigned long int*)apar));
01528 tbw += bw;
01529 out->col += bw;
01530 break;
01531 }
01532 if (get_modif(subfmt, pconv, "hh", 2))
01533 {
01534 bw = fprintf(out->file, subfmt, *((unsigned char*)apar));
01535 tbw += bw;
01536 out->col += bw;
01537 break;
01538 }
01539 if (get_modif(subfmt, pconv, "h", 1))
01540 {
01541 bw = fprintf(out->file, subfmt, *((unsigned short int*)apar));
01542 tbw += bw;
01543 out->col += bw;
01544 break;
01545 }
01546
01547 bw = fprintf(out->file, subfmt, *((unsigned int*)apar));
01548 out->col += bw;
01549 tbw += bw;
01550 break;
01551
01552
01553 case 'c':
01554 if (get_modif(subfmt, pconv, "l", 1))
01555 {
01556 bw = fprintf(out->file, subfmt, *((wchar_t *)apar));
01557 tbw += bw;
01558 out->col += bw;
01559 break;
01560 }
01561
01562 bw = fprintf(out->file, subfmt, *((char *)apar));
01563 tbw += bw;
01564 out->col += bw;
01565 break;
01566
01567
01568 case 'p':
01569 bw = fprintf(out->file, subfmt, *((void**)apar));
01570 tbw += bw;
01571 out->col += bw;
01572 break;
01573
01574
01575 case 'n':
01576 *((int*)apar) = tbw;
01577 break;
01578
01579
01580 case ' ':
01581 bw = proc_new_ln_fmt(out, subfmt);
01582 tbw += bw;
01583 break;
01584
01585
01586 default:
01587 print_err("unknown type of conversion is required", __FILE__, __LINE__, __func__);
01588 abort();
01589 }
01590
01591 idt++;
01592
01593 if (idt < nvar)
01594 {
01595 ct = tolower(types[idt]);
01596
01597
01598
01599 getsubfmt(ptypes[idt], subfmt, &pconv, 0);
01600
01601 if (ct == ' ')
01602 continue;
01603
01604
01605 if (optkwd == 0)
01606 apar = va_arg(params, void*);
01607 else
01608 {
01609 if (apar2 == NULL)
01610 {
01611 idt++;
01612 apar = va_arg(params, void*);
01613 }
01614 else
01615 apar = apar2;
01616 optkwd = 0;
01617 }
01618 }
01619 } while (idt < nvar);
01620
01621 return tbw;
01622 }
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637 long proc_new_ln_fmt(XFILE *out, const char *fmt)
01638 {
01639 long l = strlen(fmt);
01640 const char *ptrb = fmt;
01641 const char *ptre = strpbrk(fmt, "\n");
01642 char *astr = new char[l+1];
01643 long ret = 0L;
01644 int bw;
01645
01646 memset(astr, 0, sizeof(*astr)*(l+1));
01647
01648 do
01649 {
01650 if (ptre == NULL)
01651 {
01652 fprintf(out->file, ptrb, NULL);
01653 ret += fmt+l-ptrb;
01654 out->col += fmt+l-ptrb;
01655 break;
01656 }
01657 else
01658 {
01659 strncpy(astr, ptrb, ptre-ptrb);
01660 astr[ptre-ptrb] = '\0';
01661 fprintf(out->file, astr, NULL);
01662 ret += ptre-ptrb;
01663 bw = fprintf(out->file, "%s\n", out->lnpostf);
01664 ret += bw;
01665 out->line++;
01666 out->lnfpos = ftell(out->file);
01667 out->col = 1;
01668 bw = fprintf(out->file, "%s", out->lnpref);
01669 out->col += bw;
01670 ret += bw;
01671 ptrb = ptre+1;
01672 ptre = strpbrk(ptrb, "\n");
01673 }
01674 } while(1);
01675
01676 return ret;
01677 }
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695 long get_modif(const char *fmt, const char *pconv, const char *modif, int modifl)
01696 {
01697 const char *aptr;
01698 aptr = strstr(fmt, modif);
01699
01700 if (aptr)
01701 {
01702 if (aptr < pconv)
01703 {
01704 if (modifl == 1)
01705 {
01706 if (*(aptr-1) == *modif)
01707 return 0;
01708 }
01709
01710 return 1;
01711 }
01712 else
01713 return 0;
01714 }
01715
01716 return 0;
01717 }
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731 long get_num_args(const char *fmt, char **ptypes, char *types, long nvar, long fmtl)
01732 {
01733 long narg = 0L;
01734 long i;
01735
01736 char ct;
01737
01738 char **vw = new char*[nvar];
01739 memset(vw, 0, sizeof(*vw)*nvar);
01740
01741 int *avw = new int[nvar];
01742 memset(vw, 0, sizeof(*avw)*nvar);
01743
01744 char *aux;
01745 char *subfmt = new char[fmtl+1];
01746 memset(subfmt, 0, sizeof(*subfmt)*(fmtl+1));
01747
01748 for (i=0; i < nvar; i++)
01749 {
01750 ct = tolower(types[i]);
01751 if (ct == ' ')
01752 continue;
01753 narg++;
01754 if (ct == 'm')
01755 narg++;
01756 getsubfmt(ptypes[i], subfmt, 0);
01757 aux = strpbrk(subfmt, "*");
01758 if (aux)
01759 {
01760 vw[i] = aux;
01761 aux = strpbrk(subfmt, "$");
01762 if (aux)
01763 {
01764 if (sscanf(vw[i]+1, "%d", avw+i) < 1)
01765 {
01766 print_err("cannot read index of argument for variable width in the format string:\n"
01767 "\"%s\", at position %ld", __FILE__, __LINE__, __func__, fmt, long(vw[i]+1-fmt));
01768 abort();
01769 }
01770 }
01771 else
01772 narg++;
01773 }
01774 }
01775 return narg;
01776 }
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791 void clearcomments(char *lnstr)
01792 {
01793 long i = 0;
01794 while (lnstr[i] != '\0')
01795 {
01796 if (lnstr[i] == '#')
01797 {
01798 lnstr[i] = '\0';
01799 return;
01800 }
01801 i++;
01802 }
01803 return;
01804 }
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826 long checkfmt(const char *fmt)
01827 {
01828 long i, l, nt, idp;
01829 l = strlen(fmt);
01830 nt = 0;
01831 idp = 0;
01832 for(i=0; i<l; i++)
01833 {
01834 if ((fmt[i] == '%') && (idp == 0))
01835 {
01836 idp = 1;
01837 continue;
01838 }
01839 if ((fmt[i] == '%') && (idp == 1))
01840 {
01841 if (i==1)
01842 nt++;
01843 idp = 0;
01844 continue;
01845 }
01846 if ((i == 0) && (fmt[i] != '%'))
01847 nt++;
01848 if ((fmt[i] != '%') && (idp == 1))
01849 {
01850 nt++;
01851 idp = 0;
01852 }
01853 }
01854 return nt;
01855 }
01856
01857
01858
01859
01860
01861
01862
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872 void getsubfmt(const char *fmt, char *subfmt, long bc)
01873 {
01874 long i, l;
01875 const char *afmt;
01876
01877 l = strlen(fmt);
01878 i = 0;
01879 memset(subfmt, 0, sizeof(*subfmt)*(l+5));
01880
01881 if (*fmt != '%')
01882 {
01883 i=1;
01884 afmt = NULL;
01885 do
01886 {
01887 if (fmt[i] == '%')
01888 {
01889 if (fmt[i+1] == '%')
01890 i++;
01891 else
01892 break;
01893 }
01894 i++;
01895 } while(fmt[i]);
01896 }
01897 else
01898 {
01899 afmt = strpbrk(fmt, "acCdeEfFgGikmnopsSuxX[");
01900 if (afmt != NULL)
01901 {
01902 if (*afmt == '[')
01903 {
01904 if (afmt[1] == '^')
01905 afmt++;
01906 if (afmt[1] == ']')
01907 afmt++;
01908 afmt = strchr(afmt+1, ']');
01909 if (afmt == NULL)
01910 {
01911 print_err("format %[...] in %s does not contain closing ]", __FILE__, __LINE__, __func__, fmt);
01912 abort();
01913 }
01914 }
01915 i = afmt - fmt + 1;
01916 }
01917 else
01918 {
01919 print_err("unknown format specifier is required", __FILE__, __LINE__, __func__);
01920 abort();
01921 }
01922 }
01923 strncpy(subfmt, fmt, i);
01924 subfmt[i] = '\0';
01925 if (bc)
01926 strcpy(subfmt+i, "%n");
01927 }
01928
01929
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939
01940
01941
01942
01943
01944
01945
01946 void getsubfmt(const char *fmt, char *subfmt, char **pconv, long bc)
01947 {
01948 long i, l;
01949 const char *afmt;
01950
01951 l = strlen(fmt);
01952 i = 0;
01953 memset(subfmt, 0, sizeof(*subfmt)*(l+5));
01954
01955 if (*fmt != '%')
01956 {
01957 i=1;
01958 afmt = NULL;
01959 do
01960 {
01961 if (fmt[i] == '%')
01962 {
01963 if (fmt[i+1] == '%')
01964 i++;
01965 else
01966 break;
01967 }
01968 i++;
01969 } while(fmt[i]);
01970 }
01971 else
01972 {
01973 afmt = strpbrk(fmt, "acCdeEfFgGikmnopsSuxX[");
01974 if (afmt != NULL)
01975 {
01976 if (*afmt == '[')
01977 {
01978 if (afmt[1] == '^')
01979 afmt++;
01980 if (afmt[1] == ']')
01981 afmt++;
01982 afmt = strchr(afmt+1, ']');
01983 if (afmt == NULL)
01984 {
01985 print_err("format %[...] in %s does not contain closing ]", __FILE__, __LINE__, __func__, fmt);
01986 abort();
01987 }
01988 }
01989 i = afmt - fmt + 1;
01990 }
01991 else
01992 {
01993 print_err("unknown format specifier is required", __FILE__, __LINE__, __func__);
01994 abort();
01995 }
01996 }
01997
01998 strncpy(subfmt, fmt, i);
01999 subfmt[i] = '\0';
02000 if (pconv)
02001 {
02002 if (*fmt != '%')
02003 *pconv = subfmt+i-1;
02004 else
02005 *pconv = NULL;
02006 }
02007 if (bc)
02008 strcpy(subfmt+i, "%n");
02009 }
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027 void gettypes(char *fmt, char *types,char** ptypes, long nvar)
02028 {
02029 long i, j, l, idp;
02030 l = strlen(fmt);
02031 idp = 0;
02032 char *subfmt;
02033
02034 subfmt = new char[l+5];
02035 j=0;
02036 for(i=0; i<l; i++)
02037 {
02038 if ((fmt[i] != '%') && (i == 0))
02039 {
02040 ptypes[j] = fmt;
02041 j++;
02042 continue;
02043 }
02044 if ((fmt[i] == '%') && (idp == 0))
02045 {
02046 idp = 1;
02047 continue;
02048 }
02049 if ((fmt[i] == '%') && (idp == 1))
02050 {
02051 if (i==1)
02052 {
02053 ptypes[j] = fmt;
02054 j++;
02055 }
02056 idp = 0;
02057 continue;
02058 }
02059 if ((fmt[i] != '%') && (idp == 1))
02060
02061
02062 {
02063 ptypes[j] = &fmt[i-1];
02064 j++;
02065 idp = 0;
02066 }
02067 }
02068 for(i=0; i<nvar; i++)
02069 {
02070 getsubfmt(ptypes[i], subfmt, 0);
02071 if (*subfmt != '%')
02072 types[i] = ' ';
02073 else
02074 {
02075 l = strlen(subfmt);
02076 if (subfmt[l-1] == ']')
02077 types[i] = '[';
02078 else
02079 types[i] = subfmt[l-1];
02080 }
02081 }
02082 delete [] subfmt;
02083 }
02084
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098 long check_asterisk(const char *fmt)
02099 {
02100 long l = strlen(fmt);
02101 long i;
02102 long fb = 0;
02103 for(i=1; i<l; i++)
02104 {
02105 if ((fmt[i] == '*') && (fb == 0))
02106 return 1;
02107 if ((fmt[i] == '*') && (fb == 1))
02108 {
02109 print_err("invalid position of assignment suppression '*' in xfscanf", __FILE__, __LINE__, __func__);
02110 abort();
02111 }
02112 if (fb == 0)
02113 {
02114 if (isspace(fmt[i]) != 0)
02115 fb = 1;
02116 }
02117 }
02118 return 0;
02119 }
02120
02121
02122
02123
02124
02125
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136
02137
02138 long check_maxlnsize(XFILE *in, long fbr)
02139 {
02140 int c;
02141
02142
02143 if (fbr == in->give_maxlnsize())
02144 {
02145 c = getc(in->file);
02146 if ((c == '\r') || (c == '\n'))
02147 {
02148
02149 ungetc(c, in->file);
02150 return 0;
02151 }
02152 else
02153 {
02154
02155 ungetc(c, in->file);
02156
02157 if (in->maxlnover != in->line)
02158 {
02159
02160 in->maxlnover = in->line;
02161 if (in->warning)
02162 {
02163 if (in->warning == 2)
02164 {
02165 print_err("maximum length of line exceeded\n"
02166 "input file: %s, line=%ld, col=%ld",
02167 __FILE__, __LINE__, __func__, in->fname, in->line, in->give_maxlnsize());
02168 return 1;
02169 }
02170 else
02171 print_warning("maximum length of line exceeded\n"
02172 "input file: %s, line=%ld, col=%ld",
02173 __FILE__, __LINE__, __func__, in->fname, in->line, in->give_maxlnsize());
02174 }
02175 }
02176 }
02177 }
02178 return 0;
02179 }
02180
02181
02182
02183
02184
02185
02186
02187
02188
02189
02190
02191
02192
02193 long checkint(const char *lnstr)
02194 {
02195 long i=0, l;
02196 l = strlen(lnstr);
02197 while (isspace(lnstr[i]) && (i < l))
02198 i++;
02199 if (lnstr[i] == '@')
02200 return 1;
02201 while((isspace(lnstr[i])==0) && (i < l))
02202 {
02203 if (strchr("-+0123456789", lnstr[i]))
02204 i++;
02205 else
02206 {
02207 if (lnstr[i] == '@')
02208 return 0;
02209 else
02210 return 1;
02211 }
02212 }
02213 return 0;
02214 }
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229 long checkuint(const char *lnstr)
02230 {
02231 long i=0, l;
02232 l = strlen(lnstr);
02233 while (isspace(lnstr[i]) && (i < l))
02234 i++;
02235 if (lnstr[i] == '@')
02236 return 1;
02237 while((isspace(lnstr[i])==0) && (i < l))
02238 {
02239 if (strchr("+0123456789", lnstr[i]))
02240 i++;
02241 else
02242 {
02243 if (lnstr[i] == '@')
02244 return 0;
02245 else
02246 return 1;
02247 }
02248 }
02249 return 0;
02250 }
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265 long checkouint(const char *lnstr)
02266 {
02267 long i=0, l;
02268 l = strlen(lnstr);
02269 while (isspace(lnstr[i]) && (i < l))
02270 i++;
02271 if (lnstr[i] == '@')
02272 return 1;
02273 while((isspace(lnstr[i])==0) && (i < l))
02274 {
02275 if (strchr("+01234567", lnstr[i]))
02276 i++;
02277 else
02278 {
02279 if (lnstr[i] == '@')
02280 return 0;
02281 else
02282 return 1;
02283 }
02284 }
02285 return 0;
02286 }
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298
02299
02300
02301 long checkxuint(const char *lnstr)
02302 {
02303 long i=0, l;
02304 l = strlen(lnstr);
02305 while (isspace(lnstr[i]) && (i < l))
02306 i++;
02307 if (lnstr[i] == '@')
02308 return 1;
02309 while((isspace(lnstr[i])==0) && (i < l))
02310 {
02311 if (strchr("+0123456789abcdefABCDEFxX", lnstr[i]))
02312 i++;
02313 else
02314 {
02315 if (lnstr[i] == '@')
02316 return 0;
02317 else
02318 return 1;
02319 }
02320 }
02321 return 0;
02322 }
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334
02335
02336
02337 long checkreal(const char *lnstr)
02338 {
02339 long i=0, l;
02340 l = strlen(lnstr);
02341 while (isspace(lnstr[i]) && (i < l))
02342 i++;
02343 if (lnstr[i] == '@')
02344 return 1;
02345 while((isspace(lnstr[i])==0) && (i < l))
02346 {
02347 if (strchr("-+.0123456789eE", lnstr[i]))
02348 i++;
02349 else
02350 {
02351 if (lnstr[i] == '@')
02352 return 0;
02353 else
02354 return 1;
02355 }
02356 }
02357 return 0;
02358 }
02359
02360
02361
02362
02363
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374 long isemptystr(const char *lnstr,const char *filter)
02375 {
02376 long i = 0;
02377 while(lnstr[i] != '\0')
02378 {
02379 if (strchr(filter, lnstr[i]) == NULL)
02380 return 0;
02381 i++;
02382 }
02383 return 1;
02384 }
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408 void checkfeof(XFILE *in, const char *fmt, long idt, const char *ptype, char *subfmt, char *types, void *apar,
02409 const char *errfile, int errline, const char *errfunc)
02410 {
02411
02412 if ((types[idt] == ' ') && (ptype[0] == ' '))
02413 return;
02414
02415
02416 if ((types[idt] == 'k') && (ptype[1] == '+'))
02417 return;
02418
02419 if (feof(in->file))
02420 {
02421 getsubfmt(ptype, subfmt, 0);
02422 if (tolower(types[idt]) == 'k')
02423 print_err("end of file was reached - reading of keyword '%s' cannot be continued\n"
02424 "(format '%s', subformat '%s', parameter id=%ld)\n"
02425 "input file: %s, line=%ld, column=%ld",
02426 errfile, errline, errfunc, (char *)apar, fmt, subfmt, idt+1, in->fname, in->line, in->col);
02427 else
02428 print_err("end of file was reached - reading cannot be continued\n"
02429 "(format '%s', subformat '%s', parameter id=%ld)\n"
02430 "input file: %s, line=%ld, column=%ld",
02431 errfile, errline, errfunc, fmt, subfmt, idt+1, in->fname, in->line, in->col);
02432 abort();
02433 }
02434 return;
02435 }
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460 void checkeos(XFILE *in,char *fmt, long idt,char *ptype,char *subfmt, char *types, void *apar,
02461 char *errfile, int errline, const char *errfunc)
02462 {
02463 switch (in->kwdmode)
02464 {
02465 case ignore:
02466 case sequent_mode:
02467 case line_mode:
02468 return;
02469 default:
02470 break;
02471 }
02472
02473 if ((types[idt] == ' ') && (ptype[0] == ' '))
02474 return;
02475
02476
02477 if ((types[idt] == 'k') && (ptype[1] == '+'))
02478 return;
02479
02480 long pos = ftell(in->file);
02481 if ((in->line == in->asect->end_secln) &&
02482 (pos > in->asect->end_secpos))
02483 {
02484 getsubfmt(ptype, subfmt, 0);
02485 if ((tolower(types[idt]) == 'k'))
02486 print_err("end of section '%s' was reached - reading of keyword '%s' cannot be continued\n"
02487 "(format '%s', subformat '%s', parameter id=%ld)\n"
02488 "input file: %s, line=%ld, column=%ld",
02489 errfile, errline, errfunc, in->asect->name.alias, (char *)apar, fmt, subfmt, idt+1,
02490 in->fname, in->line, in->col);
02491 else
02492 print_err("end of section '%s' was reached - reading cannot be continued\n"
02493 "(format '%s', subformat '%s', parameter id=%ld)\n"
02494 "input file: %s, line=%ld, column=%ld",
02495 errfile, errline, errfunc, in->asect->name.alias, fmt, subfmt, idt+1,
02496 in->fname, in->line, in->col);
02497 abort();
02498 }
02499 return;
02500 }
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510
02511
02512
02513
02514
02515
02516 long check_feof_eos(XFILE *in)
02517 {
02518 if (feof(in->file))
02519 return 1;
02520
02521 switch (in->kwdmode)
02522 {
02523 case ignore:
02524 case sequent_mode:
02525 case line_mode:
02526 return 0;
02527 default:
02528 break;
02529 }
02530 long pos = ftell(in->file);
02531 if ((in->line == in->asect->end_secln) &&
02532 (pos > in->asect->end_secpos))
02533 return 1;
02534
02535 return 0;
02536 }
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551 void cut_str_sec(XFILE *in, char *lnstr)
02552 {
02553 switch (in->kwdmode)
02554 {
02555 case ignore:
02556 case sequent_mode:
02557 case line_mode:
02558 return;
02559 default:
02560 break;
02561 }
02562 if (in->asect->end_secln == in->line)
02563 lnstr[in->asect->end_seccol-1]='\0';
02564 return;
02565 }
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577
02578
02579
02580
02581
02582
02583
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593 long checkscanferr(XFILE *in, long ret, long reqret, long war, const char *partmsg,
02594 const char *fmt, char *subfmt, long idt, const char *ptype, const char *errfile,
02595 int errline, const char *errfunc)
02596 {
02597 if (ret != reqret)
02598 {
02599 getsubfmt(ptype, subfmt, 0);
02600 print_err("%s\n(format '%s', subformat '%s', parameter id=%ld)\n"
02601 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
02602 partmsg, fmt, subfmt, idt+1, in->fname, in->line, in->col);
02603 return 1;
02604 }
02605 if (war && in->warning)
02606 {
02607 getsubfmt(ptype, subfmt, 0);
02608 if (in->warning == 2)
02609 {
02610 print_err("%s\n"
02611 "(format '%s', subformat '%s', parameter id=%ld)\n"
02612 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
02613 partmsg, fmt, subfmt, idt+1, in->fname, in->line, in->col);
02614 return 1;
02615 }
02616 if (in->warning == 1)
02617 {
02618 print_warning("%s\n"
02619 "(format '%s', subformat '%s', parameter id=%ld)\n"
02620 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
02621 partmsg, fmt, subfmt, idt+1, in->fname, in->line, in->col);
02622 }
02623 }
02624 return 0;
02625 }
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648 long getkwd(XFILE *in,char *lnstr, char *&aptr,char *apar, unsigned int &br)
02649 {
02650 long l, tl, lkwd, noc;
02651 char *kwd_beg;
02652 char *kwd_beg2;
02653 char *tmpstr;
02654 switch (in->kwdmode)
02655 {
02656 case ignore:
02657 case sect_mode_ignore:
02658 br = 0;
02659 break;
02660 case sequent_mode:
02661 br = 0;
02662 lkwd = strlen(apar);
02663 if (lkwd < 1)
02664 return 3;
02665 kwd_beg = NULL;
02666 l = strlen(aptr);
02667 tmpstr = new char[l+1];
02668 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02669 sscanf(aptr, "%s", tmpstr);
02670 tl = strlen(tmpstr);
02671 if (tl == lkwd)
02672 kwd_beg = strstr(tmpstr, apar, in->ignorecase);
02673 delete [] tmpstr;
02674 if (kwd_beg == NULL)
02675 return 1;
02676 else
02677 {
02678 kwd_beg = strstr(aptr, apar, in->ignorecase);
02679 br = kwd_beg-aptr+lkwd;
02680 }
02681 break;
02682 case line_mode:
02683 br = 0;
02684 lkwd = strlen(apar);
02685 if (lkwd < 1)
02686 return 3;
02687 kwd_beg = strstr(lnstr, apar, in->ignorecase);
02688 if (kwd_beg == NULL)
02689 return 1;
02690 l = strlen(lnstr);
02691 tmpstr = new char[l+1];
02692 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02693 sscanf(kwd_beg, "%s", tmpstr);
02694 tl = strlen(tmpstr);
02695 if (tl != lkwd)
02696 {
02697 delete [] tmpstr;
02698 return 1;
02699 }
02700
02701 kwd_beg2 = strstr(kwd_beg+lkwd, apar, in->ignorecase);
02702 if (kwd_beg2)
02703 {
02704 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02705 sscanf(kwd_beg2, "%s", tmpstr);
02706 tl = strlen(tmpstr);
02707 if (tl != lkwd)
02708 {
02709 delete [] tmpstr;
02710 return 2;
02711 }
02712 }
02713 delete [] tmpstr;
02714 br = kwd_beg - lnstr + lkwd;
02715 break;
02716 case sect_mode_seq:
02717 case sect_mode_fwd:
02718 case sect_mode_full:
02719 br = 0;
02720 lkwd = strlen(apar);
02721 if (lkwd < 1)
02722 return 3;
02723 noc = getkwd_sect(in, lnstr, aptr, apar, 0);
02724 if (noc == 0)
02725 return 1;
02726 if (noc > 1)
02727 return 2;
02728 break;
02729 default:
02730 print_err("Unknown type of keyword handling mode is required\n", __FILE__, __LINE__, __func__);
02731 abort();
02732 }
02733 return 0;
02734 }
02735
02736
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770
02771
02772
02773
02774 long getkwd_sect(XFILE *in,char *lnstr, char *&aptr,char * apar, long detect_allkwd)
02775 {
02776 switch (in->kwdmode)
02777 {
02778 case sect_mode_full:
02779
02780 xf_resetsec(in);
02781 break;
02782 case sect_mode_seq:
02783 case sect_mode_fwd:
02784 break;
02785 default:
02786 print_err("Unknown type of keyword handling mode is required\n", __FILE__, __LINE__, __func__);
02787 abort();
02788 }
02789
02790 if (in->index_created == 0)
02791 {
02792 print_err("Section keyword mode is required but section index is not built\n"
02793 "Use xfdetect_sect function before calling xfscanf function\n", __FILE__, __LINE__, __func__);
02794 abort();
02795 }
02796 if ((in->id_sec < 0) || (in->id_sec > in->num_sec))
02797 {
02798 print_err("Section id is out of range\n", __FILE__, __LINE__, __func__);
02799 abort();
02800 }
02801
02802 long tnoc = 0;
02803 long noc = 0;
02804 char *kwd_loc = NULL;
02805 size_t kwdl = strlen(apar);
02806 long l;
02807 char *loc = NULL;
02808 char *astr;
02809 char rfmt[20];
02810 long br = 0;
02811 long fkwd_line;
02812 long fkwd_col;
02813 long fkwd_lnfpos;
02814 long fkwd_endlnfpos;
02815
02816 astr = new char[in->give_maxlnsize()+1];
02817 astr[0] = '\0';
02818 if ((lnstr == NULL) || (in->kwdmode == sect_mode_full))
02819 {
02820
02821
02822 strcpy(astr, in->lnstr+in->col-1);
02823 }
02824 else
02825 {
02826
02827 strcpy(astr, aptr);
02828 }
02829 do
02830 {
02831 if (kwd_loc == NULL)
02832 kwd_loc = locate_kwd(astr, apar, in->ignorecase, noc);
02833 else
02834 loc = locate_kwd(astr, apar, in->ignorecase, noc);
02835
02836 if (kwd_loc && (tnoc==0))
02837 {
02838 if (br && lnstr)
02839 strcpy(lnstr, astr);
02840 if (lnstr == NULL)
02841 strcpy(in->lnstr, astr);
02842
02843 fkwd_col = in->col + kwd_loc - astr;
02844 fkwd_line = in->line;
02845 fkwd_lnfpos = in->lnfpos;
02846 fkwd_endlnfpos = ftell(in->file);;
02847 if (lnstr)
02848 {
02849
02850
02851 fkwd_col += kwdl;
02852 if (br == 0)
02853 aptr += kwd_loc - astr + kwdl;
02854 else
02855 aptr = lnstr + fkwd_col - 1;
02856 }
02857 if (detect_allkwd == 0)
02858 {
02859 tnoc = 1;
02860
02861 break;
02862 }
02863 else
02864 tnoc += noc;
02865 }
02866 else
02867 {
02868
02869 if ((in->kwdmode == sect_mode_seq) && (kwd_loc == NULL))
02870 {
02871
02872 if (isemptystr(astr, " \t\n\r") == 0)
02873 break;
02874 }
02875 if (loc)
02876 tnoc += noc;
02877 }
02878 loc = NULL;
02879
02880 if (in->line < in->asect->end_secln)
02881 {
02882 astr[0] = '\0';
02883 fscanf(in->file, "%*1[\n]");
02884 in->line++;
02885 in->col = 1;
02886 in->lnfpos = ftell(in->file);
02887
02888 sprintf(rfmt, "%%%ld[^\n]", in->give_maxlnsize());
02889 fscanf(in->file, rfmt, astr);
02890 br = 1;
02891
02892 cut_str_sec(in, astr);
02893
02894 l = strlen(astr);
02895 if (l > 0)
02896 {
02897 if (astr[l-1] == '\r')
02898 astr[l-1] = '\0';
02899 }
02900 clearcomments(astr);
02901 }
02902 else
02903 break;
02904
02905 } while (1);
02906
02907 if (kwd_loc)
02908 {
02909 in->line = fkwd_line;
02910 in->col = fkwd_col;
02911 in->lnfpos = fkwd_lnfpos;
02912 fseek(in->file, fkwd_endlnfpos, SEEK_SET);
02913 }
02914 delete [] astr;
02915 return tnoc;
02916 }
02917
02918
02919
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933
02934
02935
02936
02937
02938 long getkwd_opt(XFILE *in,char *lnstr, char *&aptr,char *apar, unsigned int &br)
02939 {
02940 long l, tl, lkwd, noc;
02941 char *kwd_beg;
02942 char *kwd_beg2;
02943 char *tmpstr;
02944 switch (in->kwdmode)
02945 {
02946 case ignore:
02947 case sect_mode_ignore:
02948 br = 0;
02949 break;
02950 case sequent_mode:
02951 lkwd = strlen(apar);
02952 if (lkwd < 1)
02953 return 3;
02954 kwd_beg = NULL;
02955 l = strlen(aptr);
02956 tmpstr = new char[l+1];
02957 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02958 sscanf(aptr, "%s", tmpstr);
02959 tl = strlen(tmpstr);
02960 if (tl == lkwd)
02961 kwd_beg = strstr(tmpstr, apar, in->ignorecase);
02962 delete [] tmpstr;
02963 if (kwd_beg == NULL)
02964 return 1;
02965 else
02966 {
02967 kwd_beg = strstr(aptr, apar, in->ignorecase);
02968 br = kwd_beg-aptr+lkwd;
02969 }
02970 break;
02971 case line_mode:
02972 lkwd = strlen(apar);
02973 if (lkwd < 1)
02974 return 3;
02975 kwd_beg = strstr(lnstr, apar, in->ignorecase);
02976 if (kwd_beg == NULL)
02977 return 1;
02978 l = strlen(lnstr);
02979 tmpstr = new char[l+1];
02980 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02981 sscanf(kwd_beg, "%s", tmpstr);
02982 tl = strlen(tmpstr);
02983 if (tl != lkwd)
02984 {
02985 delete [] tmpstr;
02986 return 1;
02987 }
02988
02989 kwd_beg2 = strstr(kwd_beg+lkwd, apar, in->ignorecase);
02990 if (kwd_beg2)
02991 {
02992 memset(tmpstr, 0, sizeof(*tmpstr)*(l+1));
02993 sscanf(kwd_beg2, "%s", tmpstr);
02994 tl = strlen(tmpstr);
02995 if (tl != lkwd)
02996 {
02997 delete [] tmpstr;
02998 return 2;
02999 }
03000 }
03001 delete [] tmpstr;
03002 br = kwd_beg - lnstr + lkwd;
03003 break;
03004 case sect_mode_seq:
03005 case sect_mode_fwd:
03006 case sect_mode_full:
03007 lkwd = strlen(apar);
03008 if (lkwd < 1)
03009 return 3;
03010 noc = getkwd_sect(in, lnstr, aptr, apar, 0);
03011 if (noc == 0)
03012 return 1;
03013 if (noc > 1)
03014 return 2;
03015 break;
03016 default:
03017 print_err("Unknown type of keyword handling mode is required\n", __FILE__, __LINE__, __func__);
03018 abort();
03019 }
03020 return 0;
03021 }
03022
03023
03024
03025
03026
03027
03028
03029
03030
03031
03032
03033
03034
03035
03036
03037
03038
03039
03040
03041
03042
03043
03044
03045
03046 long getenum(const char *lnstr, kwdset *akwdset, int *apar, unsigned int &br, long &war, int handling, long ignorecase)
03047 {
03048 long l, n, tbr;
03049 char *ekwd;
03050 long ret = 1;
03051 int aux;
03052
03053 war = 0;
03054 if (apar == NULL)
03055 apar = &aux;
03056 switch (handling)
03057 {
03058 case ignore:
03059
03060 war = checkint(lnstr);
03061 ret = sscanf(lnstr, "%d%n",apar,&br);
03062 if (ret != 1)
03063 ret = 2;
03064 else
03065 {
03066 if (akwdset)
03067 {
03068 if (matchekwdint(apar, akwdset))
03069 ret = 1;
03070 else
03071 ret = 3;
03072 }
03073 }
03074 break;
03075 default:
03076
03077 if (akwdset == NULL)
03078 return 5;
03079 l = strlen(lnstr);
03080 ekwd = new char[l+1];
03081 n = sscanf(lnstr, "%s%n", ekwd, &br);
03082 l = strlen(ekwd);
03083 tbr = br-l;
03084 if (n != 1)
03085 {
03086 ret=4;
03087 }
03088 else
03089 {
03090 if (matchekwd(ekwd, akwdset, apar, ignorecase))
03091 ret = 1;
03092 else
03093 {
03094
03095 war = checkint(ekwd);
03096 ret = sscanf(ekwd, "%d%n",apar,&br);
03097 br += tbr;
03098 if (ret != 1)
03099 ret = 4;
03100 else
03101 {
03102 if (matchekwdint(apar, akwdset))
03103 ret = 1;
03104 else
03105 ret = 3;
03106 }
03107 }
03108 }
03109 delete [] ekwd;
03110 }
03111 return ret;
03112 }
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126
03127
03128
03129
03130
03131 long matchekwd(const char *ekwd, kwdset *akwdset, int *apar, long ignorecase)
03132 {
03133 long i, lkwd, tl;
03134 const char *kwd_beg;
03135 long ret=0;
03136 long pos_ok;
03137
03138 for(i=0; i<akwdset->n; i++)
03139 {
03140 kwd_beg = strstr(ekwd, akwdset->set[i].alias, ignorecase);
03141 if (kwd_beg)
03142 {
03143 tl = strlen(kwd_beg);
03144 lkwd = strlen(akwdset->set[i].alias);
03145
03146
03147
03148 pos_ok = 0;
03149 if (kwd_beg != ekwd)
03150 {
03151 if (isspace(*(kwd_beg-1)))
03152 pos_ok = 1;
03153 }
03154 else
03155 pos_ok = 1;
03156
03157 if ((tl == lkwd) && pos_ok)
03158 {
03159 *apar = akwdset->set[i].id;
03160 ret = 1;
03161 break;
03162 }
03163 }
03164 }
03165 return ret;
03166 }
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177
03178
03179
03180
03181
03182 long matchekwdint(int *apar, kwdset *akwdset)
03183 {
03184 long i;
03185 long ret=0;
03186 for(i=0; i<akwdset->n; i++)
03187 {
03188 if (*apar == akwdset->set[i].id)
03189 {
03190 ret = 1;
03191 break;
03192 }
03193 }
03194 return ret;
03195 }
03196
03197
03198
03199
03200
03201
03202
03203
03204
03205
03206
03207
03208
03209
03210
03211
03212
03213
03214
03215
03216
03217
03218
03219
03220
03221
03222
03223
03224 long checkenumerr(XFILE *in, long ret, long reqret, long war, kwdset *akwdset,
03225 const char *fmt, char *subfmt, long idt, const char *ptype, const char *errfile,
03226 int errline, const char *errfunc)
03227 {
03228 long i;
03229 char *partmsg;
03230
03231 if (ret != reqret)
03232 {
03233 switch (ret)
03234 {
03235 case 2:
03236 partmsg = "cannot read integer id of enum";
03237 break;
03238 case 3:
03239 partmsg = "enum integer id was not found in keyword set";
03240 break;
03241 case 4:
03242 partmsg = "cannot read enum keyword nor integer id";
03243 break;
03244 case 5:
03245 partmsg = "keyword set was not specified in source code file";
03246 break;
03247 default:
03248 partmsg = "cannot read enum";
03249 }
03250 getsubfmt(ptype, subfmt, 0);
03251 print_err("%s\n"
03252 "(format '%s', subformat '%s', parameter id=%ld)\n"
03253 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
03254 partmsg, fmt, subfmt, idt+1, in->fname, in->line, in->col);
03255 if (akwdset == NULL)
03256 fprintf(stderr, "No keyword set was specified\n");
03257 else
03258 {
03259 fprintf(stderr, "Following values are allowed for this enum:\n");
03260 for (i=0; i < akwdset->n; i++)
03261 fprintf(stderr, "%s (%d)\n", akwdset->set[i].alias, akwdset->set[i].id);
03262 }
03263 return 1;
03264 }
03265 if (war && in->warning)
03266 {
03267 getsubfmt(ptype, subfmt, 0);
03268 if (in->warning == 2)
03269 {
03270 print_err("\n(format '%s', subformat '%s', parameter id=%ld)\n"
03271 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
03272 fmt, subfmt, idt+1, in->fname, in->line, in->col);
03273 return 1;
03274 }
03275 if (in->warning == 1)
03276 {
03277 print_warning("unable to read integer\n(format '%s', subformat '%s', parameter id=%ld)\n"
03278 "input file: %s, line=%ld, column=%ld", errfile, errline, errfunc,
03279 fmt, subfmt, idt+1, in->fname, in->line, in->col);
03280 }
03281 }
03282 return 0;
03283 }
03284
03285
03286
03287
03288
03289
03290
03291
03292
03293
03294
03295
03296
03297
03298
03299 char *strstr(char *haystack, const char *needle, long ignorecase)
03300 {
03301 char *ret;
03302 if (ignorecase==1)
03303 ret = strstrcis(haystack, needle);
03304 else
03305 ret = strstr(haystack, needle);
03306 return ret;
03307 }
03308
03309
03310
03311
03312
03313
03314
03315
03316
03317
03318
03319
03320
03321
03322
03323
03324
03325 const char *strstr(const char *haystack, const char *needle, long ignorecase)
03326 {
03327 const char *ret;
03328 if (ignorecase==1)
03329 ret = strstrcis(haystack, needle);
03330 else
03331 ret = strstr(haystack, needle);
03332 return ret;
03333 }
03334
03335
03336
03337
03338
03339
03340
03341
03342
03343
03344
03345
03346
03347
03348
03349 char *strstrcis(char *haystack, const char *needle)
03350 {
03351 long i, j, lh, ln;
03352 lh = strlen(haystack);
03353 ln = strlen(needle);
03354 j = 0;
03355
03356 if ((ln == 0) || (needle == NULL) || (haystack == NULL))
03357 return NULL;
03358
03359 for (i = 0; i<lh; i++)
03360 {
03361 if (tolower(haystack[i]) == tolower(needle[j]))
03362 {
03363 j++;
03364 if (j == ln)
03365 return (char *)(haystack+i-(j-1));
03366 }
03367 else
03368 j = 0;
03369 }
03370
03371 return NULL;
03372 }
03373
03374
03375
03376
03377
03378
03379
03380
03381
03382
03383
03384
03385
03386
03387
03388 const char *strstrcis(const char *haystack, const char *needle)
03389 {
03390 long i, j, lh, ln;
03391 lh = strlen(haystack);
03392 ln = strlen(needle);
03393 j = 0;
03394
03395 if ((ln == 0) || (needle == NULL) || (haystack == NULL))
03396 return NULL;
03397
03398 for (i = 0; i<lh; i++)
03399 {
03400 if (tolower(haystack[i]) == tolower(needle[j]))
03401 {
03402 j++;
03403 if (j == ln)
03404 return (haystack+i-(j-1));
03405 }
03406 else
03407 j = 0;
03408 }
03409
03410 return NULL;
03411 }
03412
03413
03414
03415
03416
03417
03418
03419
03420
03421
03422
03423
03424
03425
03426 void skipline(XFILE *in)
03427 {
03428 in->col = strlen(in->lnstr)+1;
03429 return;
03430 }
03431
03432
03433
03434
03435
03436
03437
03438
03439
03440
03441
03442
03443
03444
03445
03446
03447
03448
03449
03450
03451
03452
03453
03454
03455
03456
03457
03458
03459
03460
03461
03462
03463 char *proc_ord_fmt(XFILE *in, char *fmt, char *fmt_end, char *lnstr, char *&astr)
03464 {
03465 long l, err, ret;
03466 unsigned int br;
03467 char *subfmt;
03468
03469 char *afmt;
03470 char *aux;
03471
03472
03473 if (fmt_end)
03474 l = fmt_end - fmt;
03475 else
03476 l = strlen(fmt);
03477 subfmt = new char[l+1];
03478 strncpy(subfmt, fmt, l);
03479 subfmt[l] = '\0';
03480
03481 if (subfmt[0] == '%')
03482 {
03483 afmt = aux = strpbrk(subfmt, "acCdeEfFgGikmnopsSuxX[");
03484 if (*afmt == '[')
03485 {
03486 aux = strchr(afmt+1, ']');
03487 if (afmt[1] == ']')
03488 aux = strchr(afmt+2, ']');
03489 if (afmt[1] == '^')
03490 aux = strchr(afmt+3, ']');
03491 }
03492 if (aux == NULL)
03493 {
03494 print_err("invalid format %s - cannot find terminating ]", __FILE__, __LINE__, __func__, subfmt);
03495 delete [] subfmt;
03496 return NULL;
03497 }
03498
03499 afmt = aux+1;
03500 }
03501 else
03502 afmt = subfmt;
03503
03504
03505 l = strlen(afmt);
03506 if (l == 0)
03507 {
03508 delete [] subfmt;
03509 return NULL;
03510 }
03511 aux = new char[l+3];
03512 do
03513 {
03514 if (isspace(*afmt))
03515 {
03516 while (isspace(*afmt))
03517 afmt++;
03518
03519
03520 ret = skip_space(in, lnstr, astr);
03521
03522 if (ret == 2)
03523 {
03524 afmt = fmt + (afmt - subfmt);
03525 delete [] subfmt;
03526 delete [] aux;
03527 return afmt;
03528 }
03529
03530 if (ret == 1)
03531 {
03532 if (*afmt)
03533 {
03534 afmt = fmt + (afmt - subfmt);
03535 delete [] subfmt;
03536 delete [] aux;
03537 return afmt;
03538 }
03539 else
03540 {
03541 delete [] subfmt;
03542 delete [] aux;
03543 return NULL;
03544 }
03545 }
03546 }
03547 if (sscanf(afmt, "%s", aux)==1)
03548 {
03549 l = strlen(aux);
03550 sprintf(aux+l, "%%n");
03551 br = 0;
03552
03553 err = sscanf(astr, aux, &br);
03554 if ((err != EOF) && (br == l))
03555 {
03556 afmt += l;
03557 astr += l;
03558 in->col += l;
03559 }
03560 else
03561 {
03562 afmt = fmt + (afmt - subfmt);
03563 delete [] subfmt;
03564 delete [] aux;
03565 return afmt;
03566 }
03567 }
03568 } while(*afmt != '\0');
03569
03570 delete [] subfmt;
03571 delete [] aux;
03572 return NULL;
03573 }
03574
03575
03576
03577
03578
03579
03580
03581
03582
03583
03584
03585
03586
03587
03588
03589
03590
03591 long skip_space(XFILE *in, char *lnstr, char *&astr)
03592 {
03593 long l;
03594 int br;
03595 long pos;
03596 int fbr;
03597 char rfmt[20];
03598
03599 do
03600 {
03601 l = strlen(astr);
03602 br = 0;
03603 if (l != 0)
03604 {
03605 sscanf(astr, " %n", &br);
03606 astr += br;
03607 in->col += br;
03608 if (br != l)
03609 return 0;
03610 }
03611
03612
03613
03614
03615 if (feof(in->file))
03616 return 1;
03617
03618 pos = ftell(in->file);
03619 if (in->index_created)
03620 {
03621 if ((in->line == in->asect->end_secln) &&
03622 (pos > in->asect->end_secpos))
03623 return 1;
03624 }
03625 fscanf(in->file, "%*1[\n]");
03626 in->line++;
03627 in->col=1;
03628 in->lnfpos = ftell(in->file);
03629
03630
03631
03632 memset(lnstr, 0, sizeof(*lnstr)*in->give_maxlnsize()+1);
03633
03634 if (feof(in->file))
03635 return 1;
03636
03637
03638 pos = ftell(in->file);
03639 if (in->index_created)
03640 {
03641 if ((in->line == in->asect->end_secln) &&
03642 (pos > in->asect->end_secpos))
03643 return 1;
03644 }
03645
03646
03647 sprintf(rfmt, "%%%ld[^\n]%%n", in->give_maxlnsize());
03648 fbr = 0;
03649 fscanf(in->file, rfmt, lnstr, &fbr);
03650 if (check_maxlnsize(in, fbr))
03651 return 2;
03652
03653
03654 cut_str_sec(in, lnstr);
03655
03656 l = strlen(lnstr);
03657 if (l > 0)
03658 {
03659 if (lnstr[l-1] == '\r')
03660 lnstr[l-1] = '\0';
03661 }
03662 clearcomments(lnstr);
03663 astr = lnstr;
03664 } while(1);
03665
03666 return 0;
03667 }
03668
03669
03670
03671
03672
03673
03674
03675
03676
03677
03678
03679
03680
03681
03682 long check_newline_fmt(char *fmt)
03683 {
03684 long caretflag = 0;
03685 char *aux = strchr(fmt, '[');
03686 aux += 1;
03687
03688 if (*aux == '^')
03689 {
03690 caretflag = 1;
03691 aux++;
03692 }
03693
03694 while (*aux)
03695 {
03696 if ((*aux == '\n') && (caretflag == 0))
03697 return 1;
03698 if ((*aux == '\n') && (caretflag == 1))
03699 return 0;
03700 aux++;
03701 }
03702 if (caretflag)
03703 return 1;
03704 return 0;
03705 }
03706
03707
03708
03709
03710
03711
03712
03713
03714
03715
03716
03717
03718
03719
03720
03721
03722 long detect_multln(char *astr)
03723 {
03724 long i, l;
03725 l = strlen(astr);
03726 for(i=l-1; i >= 0; i--)
03727 {
03728 if (isspace(astr[i])) continue;
03729 if (astr[i] == '@')
03730 {
03731 astr[i] = '\n';
03732 return 1;
03733 }
03734 }
03735 return 0;
03736 }
03737
03738
03739
03740
03741
03742
03743
03744
03745
03746
03747
03748
03749
03750
03751
03752
03753
03754
03755
03756 long a_fmt_skips_whitespaces(char *fmt)
03757 {
03758 if (fmt[0] != '%')
03759 {
03760 print_err("format string does not start with '%' character", __FILE__, __LINE__, __func__);
03761 abort();
03762 }
03763 if (fmt[1] == '*')
03764 {
03765 if (fmt[2] == ' ')
03766 return 1;
03767 else
03768 return 0;
03769 }
03770 if (fmt[1] == ' ')
03771 return 1;
03772 else
03773 return 0;
03774
03775 return 0;
03776 }
03777
03778
03779
03780
03781
03782
03783
03784
03785
03786
03787
03788
03789
03790
03791
03792 void filename_decomposition (const char *file,char *&path,char *&name,char *&suffix)
03793 {
03794 char *fix;
03795 path = new char[strlen(file)+1];
03796 name = new char[strlen(file)+1];
03797 suffix = new char[strlen(file)+1];
03798
03799 strcpy (path,file);
03800 fix = strrchr(path,'/');
03801 if (fix==NULL){
03802 strcpy (name,path);
03803 path[0] = '\0';
03804 }
03805 else{
03806 strcpy (name,fix+1);
03807 fix[1] = '\0';
03808 }
03809
03810 fix = strrchr(name,'.');
03811 if (fix==NULL)
03812 suffix[0] = '\0';
03813 else{
03814 strcpy (suffix,fix);
03815 fix[0] = '\0';
03816 }
03817 }