← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to libs/3rdparty/clapack/fmt.c

  • Committer: Package Import Robot
  • Author(s): Felix Geyer, Rohan Garg, Philip Muškovac, Felix Geyer
  • Date: 2011-09-23 18:18:55 UTC
  • mfrom: (1.2.36 upstream)
  • Revision ID: package-import@ubuntu.com-20110923181855-ifs67wxkugshev9k
Tags: 2:2.1.1-0ubuntu1
https://launchpad.net/bugs/834190
https://launchpad.net/bugs/804894
[ Rohan Garg ]
* New upstream release (LP: #834190)
  - debian/control
    + Build with libqtwebkit-dev
 - debian/kipi-plugins-common
    + Install libkvkontakte required by kipi-plugins
 - debian/digikam
    + Install panoramagui

[ Philip Muškovac ]
* New upstream release
  - debian/control:
    + Add libcv-dev, libcvaux-dev, libhighgui-dev, libboost-graph1.46-dev,
      libksane-dev, libxml2-dev, libxslt-dev, libqt4-opengl-dev, libqjson-dev,
      libgpod-dev and libqca2-dev to build-deps
    + Add packages for kipi-plugins, libmediawiki, libkface, libkgeomap and
      libkvkontakte
  - debian/rules:
    + Don't build with gphoto2 since it doesn't build with it.
  - Add kubuntu_fix_test_linking.diff to fix linking of the dngconverter test
  - update install files
  - update kubuntu_01_mysqld_executable_name.diff for new cmake layout
    and rename to kubuntu_mysqld_executable_name.diff
* Fix typo in digikam-data description (LP: #804894)
* Fix Vcs links

[ Felix Geyer ]
* Move library data files to the new packages libkface-data, libkgeomap-data
  and libkvkontakte-data.
* Override version of the embedded library packages to 1.0~digikam<version>.
* Exclude the library packages from digikam-dbg to prevent file conflicts in
  the future.
* Call dh_install with --list-missing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/3rdparty/clapack/fmt.c
1
 
#include "f2c.h"
2
 
#include "fio.h"
3
 
#include "fmt.h"
4
 
#define skip(s) while(*s==' ') s++
5
 
#ifdef interdata
6
 
#define SYLMX 300
7
 
#endif
8
 
#ifdef pdp11
9
 
#define SYLMX 300
10
 
#endif
11
 
#ifdef vax
12
 
#define SYLMX 300
13
 
#endif
14
 
#ifndef SYLMX
15
 
#define SYLMX 300
16
 
#endif
17
 
#define GLITCH '\2'
18
 
        /* special quote character for stu */
19
 
extern int f__cursor,f__scale;
20
 
extern flag f__cblank,f__cplus; /*blanks in I and compulsory plus*/
21
 
static struct syl f__syl[SYLMX];
22
 
int f__parenlvl,f__pc,f__revloc;
23
 
 
24
 
 static
25
 
#ifdef KR_headers
26
 
char *ap_end(s) char *s;
27
 
#else
28
 
char *ap_end(char *s)
29
 
#endif
30
 
{       char quote;
31
 
        quote= *s++;
32
 
        for(;*s;s++)
33
 
        {       if(*s!=quote) continue;
34
 
                if(*++s!=quote) return(s);
35
 
        }
36
 
        if(f__elist->cierr) {
37
 
                errno = 100;
38
 
                return(NULL);
39
 
        }
40
 
        f__fatal(100, "bad string");
41
 
        /*NOTREACHED*/ return 0;
42
 
}
43
 
 static
44
 
#ifdef KR_headers
45
 
op_gen(a,b,c,d)
46
 
#else
47
 
op_gen(int a, int b, int c, int d)
48
 
#endif
49
 
{       struct syl *p= &f__syl[f__pc];
50
 
        if(f__pc>=SYLMX)
51
 
        {       fprintf(stderr,"format too complicated:\n");
52
 
                sig_die(f__fmtbuf, 1);
53
 
        }
54
 
        p->op=a;
55
 
        p->p1=b;
56
 
        p->p2.i[0]=c;
57
 
        p->p2.i[1]=d;
58
 
        return(f__pc++);
59
 
}
60
 
#ifdef KR_headers
61
 
static char *f_list();
62
 
static char *gt_num(s,n,n1) char *s; int *n, n1;
63
 
#else
64
 
static char *f_list(char*);
65
 
static char *gt_num(char *s, int *n, int n1)
66
 
#endif
67
 
{       int m=0,f__cnt=0;
68
 
        char c;
69
 
        for(c= *s;;c = *s)
70
 
        {       if(c==' ')
71
 
                {       s++;
72
 
                        continue;
73
 
                }
74
 
                if(c>'9' || c<'0') break;
75
 
                m=10*m+c-'0';
76
 
                f__cnt++;
77
 
                s++;
78
 
        }
79
 
        if(f__cnt==0) {
80
 
                if (!n1)
81
 
                        s = 0;
82
 
                *n=n1;
83
 
                }
84
 
        else *n=m;
85
 
        return(s);
86
 
}
87
 
 
88
 
 static
89
 
#ifdef KR_headers
90
 
char *f_s(s,curloc) char *s;
91
 
#else
92
 
char *f_s(char *s, int curloc)
93
 
#endif
94
 
{
95
 
        skip(s);
96
 
        if(*s++!='(')
97
 
        {
98
 
                return(NULL);
99
 
        }
100
 
        if(f__parenlvl++ ==1) f__revloc=curloc;
101
 
        if(op_gen(RET1,curloc,0,0)<0 ||
102
 
                (s=f_list(s))==NULL)
103
 
        {
104
 
                return(NULL);
105
 
        }
106
 
        skip(s);
107
 
        return(s);
108
 
}
109
 
 
110
 
 static
111
 
#ifdef KR_headers
112
 
ne_d(s,p) char *s,**p;
113
 
#else
114
 
ne_d(char *s, char **p)
115
 
#endif
116
 
{       int n,x,sign=0;
117
 
        struct syl *sp;
118
 
        switch(*s)
119
 
        {
120
 
        default:
121
 
                return(0);
122
 
        case ':': (void) op_gen(COLON,0,0,0); break;
123
 
        case '$':
124
 
                (void) op_gen(NONL, 0, 0, 0); break;
125
 
        case 'B':
126
 
        case 'b':
127
 
                if(*++s=='z' || *s == 'Z') (void) op_gen(BZ,0,0,0);
128
 
                else (void) op_gen(BN,0,0,0);
129
 
                break;
130
 
        case 'S':
131
 
        case 's':
132
 
                if(*(s+1)=='s' || *(s+1) == 'S')
133
 
                {       x=SS;
134
 
                        s++;
135
 
                }
136
 
                else if(*(s+1)=='p' || *(s+1) == 'P')
137
 
                {       x=SP;
138
 
                        s++;
139
 
                }
140
 
                else x=S;
141
 
                (void) op_gen(x,0,0,0);
142
 
                break;
143
 
        case '/': (void) op_gen(SLASH,0,0,0); break;
144
 
        case '-': sign=1;
145
 
        case '+':       s++;    /*OUTRAGEOUS CODING TRICK*/
146
 
        case '0': case '1': case '2': case '3': case '4':
147
 
        case '5': case '6': case '7': case '8': case '9':
148
 
                if (!(s=gt_num(s,&n,0))) {
149
 
 bad:                   *p = 0;
150
 
                        return 1;
151
 
                        }
152
 
                switch(*s)
153
 
                {
154
 
                default:
155
 
                        return(0);
156
 
                case 'P':
157
 
                case 'p': if(sign) n= -n; (void) op_gen(P,n,0,0); break;
158
 
                case 'X':
159
 
                case 'x': (void) op_gen(X,n,0,0); break;
160
 
                case 'H':
161
 
                case 'h':
162
 
                        sp = &f__syl[op_gen(H,n,0,0)];
163
 
                        sp->p2.s = s + 1;
164
 
                        s+=n;
165
 
                        break;
166
 
                }
167
 
                break;
168
 
        case GLITCH:
169
 
        case '"':
170
 
        case '\'':
171
 
                sp = &f__syl[op_gen(APOS,0,0,0)];
172
 
                sp->p2.s = s;
173
 
                if((*p = ap_end(s)) == NULL)
174
 
                        return(0);
175
 
                return(1);
176
 
        case 'T':
177
 
        case 't':
178
 
                if(*(s+1)=='l' || *(s+1) == 'L')
179
 
                {       x=TL;
180
 
                        s++;
181
 
                }
182
 
                else if(*(s+1)=='r'|| *(s+1) == 'R')
183
 
                {       x=TR;
184
 
                        s++;
185
 
                }
186
 
                else x=T;
187
 
                if (!(s=gt_num(s+1,&n,0)))
188
 
                        goto bad;
189
 
                s--;
190
 
                (void) op_gen(x,n,0,0);
191
 
                break;
192
 
        case 'X':
193
 
        case 'x': (void) op_gen(X,1,0,0); break;
194
 
        case 'P':
195
 
        case 'p': (void) op_gen(P,1,0,0); break;
196
 
        }
197
 
        s++;
198
 
        *p=s;
199
 
        return(1);
200
 
}
201
 
 
202
 
 static
203
 
#ifdef KR_headers
204
 
e_d(s,p) char *s,**p;
205
 
#else
206
 
e_d(char *s, char **p)
207
 
#endif
208
 
{       int i,im,n,w,d,e,found=0,x=0;
209
 
        char *sv=s;
210
 
        s=gt_num(s,&n,1);
211
 
        (void) op_gen(STACK,n,0,0);
212
 
        switch(*s++)
213
 
        {
214
 
        default: break;
215
 
        case 'E':
216
 
        case 'e':       x=1;
217
 
        case 'G':
218
 
        case 'g':
219
 
                found=1;
220
 
                if (!(s=gt_num(s,&w,0))) {
221
 
 bad:
222
 
                        *p = 0;
223
 
                        return 1;
224
 
                        }
225
 
                if(w==0) break;
226
 
                if(*s=='.') {
227
 
                        if (!(s=gt_num(s+1,&d,0)))
228
 
                                goto bad;
229
 
                        }
230
 
                else d=0;
231
 
                if(*s!='E' && *s != 'e')
232
 
                        (void) op_gen(x==1?E:G,w,d,0);  /* default is Ew.dE2 */
233
 
                else {
234
 
                        if (!(s=gt_num(s+1,&e,0)))
235
 
                                goto bad;
236
 
                        (void) op_gen(x==1?EE:GE,w,d,e);
237
 
                        }
238
 
                break;
239
 
        case 'O':
240
 
        case 'o':
241
 
                i = O;
242
 
                im = OM;
243
 
                goto finish_I;
244
 
        case 'Z':
245
 
        case 'z':
246
 
                i = Z;
247
 
                im = ZM;
248
 
                goto finish_I;
249
 
        case 'L':
250
 
        case 'l':
251
 
                found=1;
252
 
                if (!(s=gt_num(s,&w,0)))
253
 
                        goto bad;
254
 
                if(w==0) break;
255
 
                (void) op_gen(L,w,0,0);
256
 
                break;
257
 
        case 'A':
258
 
        case 'a':
259
 
                found=1;
260
 
                skip(s);
261
 
                if(*s>='0' && *s<='9')
262
 
                {       s=gt_num(s,&w,1);
263
 
                        if(w==0) break;
264
 
                        (void) op_gen(AW,w,0,0);
265
 
                        break;
266
 
                }
267
 
                (void) op_gen(A,0,0,0);
268
 
                break;
269
 
        case 'F':
270
 
        case 'f':
271
 
                if (!(s=gt_num(s,&w,0)))
272
 
                        goto bad;
273
 
                found=1;
274
 
                if(w==0) break;
275
 
                if(*s=='.') {
276
 
                        if (!(s=gt_num(s+1,&d,0)))
277
 
                                goto bad;
278
 
                        }
279
 
                else d=0;
280
 
                (void) op_gen(F,w,d,0);
281
 
                break;
282
 
        case 'D':
283
 
        case 'd':
284
 
                found=1;
285
 
                if (!(s=gt_num(s,&w,0)))
286
 
                        goto bad;
287
 
                if(w==0) break;
288
 
                if(*s=='.') {
289
 
                        if (!(s=gt_num(s+1,&d,0)))
290
 
                                goto bad;
291
 
                        }
292
 
                else d=0;
293
 
                (void) op_gen(D,w,d,0);
294
 
                break;
295
 
        case 'I':
296
 
        case 'i':
297
 
                i = I;
298
 
                im = IM;
299
 
 finish_I:
300
 
                if (!(s=gt_num(s,&w,0)))
301
 
                        goto bad;
302
 
                found=1;
303
 
                if(w==0) break;
304
 
                if(*s!='.')
305
 
                {       (void) op_gen(i,w,0,0);
306
 
                        break;
307
 
                }
308
 
                if (!(s=gt_num(s+1,&d,0)))
309
 
                        goto bad;
310
 
                (void) op_gen(im,w,d,0);
311
 
                break;
312
 
        }
313
 
        if(found==0)
314
 
        {       f__pc--; /*unSTACK*/
315
 
                *p=sv;
316
 
                return(0);
317
 
        }
318
 
        *p=s;
319
 
        return(1);
320
 
}
321
 
 static
322
 
#ifdef KR_headers
323
 
char *i_tem(s) char *s;
324
 
#else
325
 
char *i_tem(char *s)
326
 
#endif
327
 
{       char *t;
328
 
        int n,curloc;
329
 
        if(*s==')') return(s);
330
 
        if(ne_d(s,&t)) return(t);
331
 
        if(e_d(s,&t)) return(t);
332
 
        s=gt_num(s,&n,1);
333
 
        if((curloc=op_gen(STACK,n,0,0))<0) return(NULL);
334
 
        return(f_s(s,curloc));
335
 
}
336
 
 
337
 
 static
338
 
#ifdef KR_headers
339
 
char *f_list(s) char *s;
340
 
#else
341
 
char *f_list(char *s)
342
 
#endif
343
 
{
344
 
        for(;*s!=0;)
345
 
        {       skip(s);
346
 
                if((s=i_tem(s))==NULL) return(NULL);
347
 
                skip(s);
348
 
                if(*s==',') s++;
349
 
                else if(*s==')')
350
 
                {       if(--f__parenlvl==0)
351
 
                        {
352
 
                                (void) op_gen(REVERT,f__revloc,0,0);
353
 
                                return(++s);
354
 
                        }
355
 
                        (void) op_gen(GOTO,0,0,0);
356
 
                        return(++s);
357
 
                }
358
 
        }
359
 
        return(NULL);
360
 
}
361
 
 
362
 
#ifdef KR_headers
363
 
pars_f(s) char *s;
364
 
#else
365
 
pars_f(char *s)
366
 
#endif
367
 
{
368
 
        f__parenlvl=f__revloc=f__pc=0;
369
 
        if(f_s(s,0) == NULL)
370
 
        {
371
 
                return(-1);
372
 
        }
373
 
        return(0);
374
 
}
375
 
#define STKSZ 10
376
 
int f__cnt[STKSZ],f__ret[STKSZ],f__cp,f__rp;
377
 
flag f__workdone, f__nonl;
378
 
 
379
 
 static
380
 
#ifdef KR_headers
381
 
type_f(n)
382
 
#else
383
 
type_f(int n)
384
 
#endif
385
 
{
386
 
        switch(n)
387
 
        {
388
 
        default:
389
 
                return(n);
390
 
        case RET1:
391
 
                return(RET1);
392
 
        case REVERT: return(REVERT);
393
 
        case GOTO: return(GOTO);
394
 
        case STACK: return(STACK);
395
 
        case X:
396
 
        case SLASH:
397
 
        case APOS: case H:
398
 
        case T: case TL: case TR:
399
 
                return(NED);
400
 
        case F:
401
 
        case I:
402
 
        case IM:
403
 
        case A: case AW:
404
 
        case O: case OM:
405
 
        case L:
406
 
        case E: case EE: case D:
407
 
        case G: case GE:
408
 
        case Z: case ZM:
409
 
                return(ED);
410
 
        }
411
 
}
412
 
#ifdef KR_headers
413
 
integer do_fio(number,ptr,len) ftnint *number; ftnlen len; char *ptr;
414
 
#else
415
 
integer do_fio(ftnint *number, char *ptr, ftnlen len)
416
 
#endif
417
 
{       struct syl *p;
418
 
        int n,i;
419
 
        for(i=0;i<*number;i++,ptr+=len)
420
 
        {
421
 
loop:   switch(type_f((p= &f__syl[f__pc])->op))
422
 
        {
423
 
        default:
424
 
                fprintf(stderr,"unknown code in do_fio: %d\n%s\n",
425
 
                        p->op,f__fmtbuf);
426
 
                err(f__elist->cierr,100,"do_fio");
427
 
        case NED:
428
 
                if((*f__doned)(p))
429
 
                {       f__pc++;
430
 
                        goto loop;
431
 
                }
432
 
                f__pc++;
433
 
                continue;
434
 
        case ED:
435
 
                if(f__cnt[f__cp]<=0)
436
 
                {       f__cp--;
437
 
                        f__pc++;
438
 
                        goto loop;
439
 
                }
440
 
                if(ptr==NULL)
441
 
                        return((*f__doend)());
442
 
                f__cnt[f__cp]--;
443
 
                f__workdone=1;
444
 
                if((n=(*f__doed)(p,ptr,len))>0)
445
 
                        errfl(f__elist->cierr,errno,"fmt");
446
 
                if(n<0)
447
 
                        err(f__elist->ciend,(EOF),"fmt");
448
 
                continue;
449
 
        case STACK:
450
 
                f__cnt[++f__cp]=p->p1;
451
 
                f__pc++;
452
 
                goto loop;
453
 
        case RET1:
454
 
                f__ret[++f__rp]=p->p1;
455
 
                f__pc++;
456
 
                goto loop;
457
 
        case GOTO:
458
 
                if(--f__cnt[f__cp]<=0)
459
 
                {       f__cp--;
460
 
                        f__rp--;
461
 
                        f__pc++;
462
 
                        goto loop;
463
 
                }
464
 
                f__pc=1+f__ret[f__rp--];
465
 
                goto loop;
466
 
        case REVERT:
467
 
                f__rp=f__cp=0;
468
 
                f__pc = p->p1;
469
 
                if(ptr==NULL)
470
 
                        return((*f__doend)());
471
 
                if(!f__workdone) return(0);
472
 
                if((n=(*f__dorevert)()) != 0) return(n);
473
 
                goto loop;
474
 
        case COLON:
475
 
                if(ptr==NULL)
476
 
                        return((*f__doend)());
477
 
                f__pc++;
478
 
                goto loop;
479
 
        case NONL:
480
 
                f__nonl = 1;
481
 
                f__pc++;
482
 
                goto loop;
483
 
        case S:
484
 
        case SS:
485
 
                f__cplus=0;
486
 
                f__pc++;
487
 
                goto loop;
488
 
        case SP:
489
 
                f__cplus = 1;
490
 
                f__pc++;
491
 
                goto loop;
492
 
        case P: f__scale=p->p1;
493
 
                f__pc++;
494
 
                goto loop;
495
 
        case BN:
496
 
                f__cblank=0;
497
 
                f__pc++;
498
 
                goto loop;
499
 
        case BZ:
500
 
                f__cblank=1;
501
 
                f__pc++;
502
 
                goto loop;
503
 
        }
504
 
        }
505
 
        return(0);
506
 
}
507
 
en_fio(Void)
508
 
{       ftnint one=1;
509
 
        return(do_fio(&one,(char *)NULL,(ftnint)0));
510
 
}
511
 
 VOID
512
 
fmt_bg(Void)
513
 
{
514
 
        f__workdone=f__cp=f__rp=f__pc=f__cursor=0;
515
 
        f__cnt[0]=f__ret[0]=0;
516
 
}