Annotation of OpenXM_contrib2/asir2018/parse/parse.h, Revision 1.8
1.1 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.8 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2018/parse/parse.h,v 1.7 2019/11/12 10:53:23 kondoh Exp $
1.1 noro 49: */
50: # if defined(VISUAL) || defined(__MINGW32__)
51: #include <time.h>
52: #else
53: #include <sys/time.h>
54: #include <sys/resource.h>
55: #endif
56: #include <setjmp.h>
57: #ifdef ABS
58: #undef ABS
59: #define ABS(a) ((a)>0?(a):-(a))
60: #endif
61:
62: #include <math.h>
63: #include <ctype.h>
64:
65: /* identifiers for expressions */
66:
67: typedef enum {
68: I_BOP, I_COP, I_AND, I_OR, I_NOT, I_CE,
69: I_PRESELF, I_POSTSELF,
70: I_FUNC, I_FUNC_OPT, I_IFUNC, I_MAP, I_RECMAP, I_PFDERIV,
71: I_ANS, I_PVAR, I_ASSPVAR,
72: I_FORMULA, I_LIST, I_STR, I_NEWCOMP, I_CAR, I_CDR, I_CAST,
73: I_INDEX, I_EV, I_TIMER, I_GF2NGEN, I_GFPNGEN, I_GFSNGEN,
74: I_LOP, I_OPT, I_GETOPT, I_POINT, I_PAREN, I_MINUS,
75: I_NARYOP, I_CONS, I_FUNC_QARG, I_FUNC_HEAD, I_EVM
76: } fid;
77:
78: /* identifiers for statements */
79:
80: typedef enum {
81: S_BP, S_PFDEF,
82: S_SINGLE, S_CPLX,
83: S_IFELSE, S_FOR, S_DO,
84: S_BREAK, S_RETURN, S_CONTINUE,
85: S_MODULE
86: } sid;
87:
88: /* identifiers for comparison operators */
89:
90: typedef enum { C_LT, C_GT, C_LE, C_GE, C_EQ, C_NE } cid;
91:
92: /* identifiers for logical operators */
93:
94: typedef enum { L_LT, L_GT, L_LE, L_GE, L_EQ, L_NE, L_AND, L_OR, L_NOT, L_IMPL, L_REPL, L_EQUIV } lid;
95:
96: /* identifiers for functions */
97:
98: typedef enum { A_UNDEF, A_BIN, A_USR, A_PURE, A_PARI } aid;
99:
100: /* identifiers for indeterminates */
101:
102: typedef enum { V_IND, V_UC, V_PF, V_SR } vid;
103:
104: typedef struct oVS {
105: unsigned int n;
106: unsigned int asize;
107: unsigned int at;
108: unsigned int level;
109: struct oFUNC *usrf;
110: struct oPV *va;
111: NODE opt;
112: } *VS;
113:
114: typedef struct oMODULE {
115: char *name;
116: VS pvs;
117: NODE usrf_list;
118: } *MODULE;
119:
120: typedef struct oPV {
121: char *name;
122: short attr,type;
123: pointer priv;
124: } *PV;
125:
126: typedef struct oINFILE {
127: char *name;
128: FILE *fp;
129: JMP_BUF jmpbuf;
130: int ready_for_longjmp;
131: int ln;
132: struct oINFILE *next;
133: char *tname;
134: int encoded;
135: short vol;
136: } *INFILE;
137:
138: struct oTKWD {
139: char *name;
140: int token;
141: };
142:
143: typedef struct fid_spec {
144: fid id;
145: farg_type type[10];
146: } *fid_spec_p;
147:
148: typedef struct oARF {
149: char *name;
150: void (*fp)();
151: } *ARF;
152:
153: typedef struct oFUNC {
154: char *name,*fullname;
155: int argc;
156: int type;
157: int secure;
158: aid id;
159: unsigned int quote;
160: union {
161: void (*binf)();
162: struct oUSRF *usrf;
163: struct oPF *puref;
164: } f;
165: } *FUNC;
166:
167: typedef struct oUSRF {
168: char *fname;
169: MODULE module;
170: int startl,endl;
171: NODE args;
172: VS pvs;
173: char *desc;
174: struct oSNODE *body;
175: } *USRF;
176:
177: typedef struct oPF {
178: char *name;
179: int argc;
180: Obj body;
181: V *args;
182: Obj *deriv;
183: NODE ins;
184: int (*pari)();
185: double (*libm)();
186: int (*simplify)();
1.7 kondoh 187: #if defined(INTERVAL)
188: void (**intervalfunc)();
189: #endif
1.1 noro 190: } *PF;
191:
192: typedef struct oPFAD {
193: Obj arg;
194: int d;
195: } *PFAD;
196:
197: typedef struct oPFINS {
198: struct oPF *pf;
199: struct oPFAD ad[1];
200: } *PFINS;
201:
202: #define NEWPF(p) ((p)=(PF)MALLOC(sizeof(struct oPF)))
203:
204: typedef struct oFNODE {
205: short id;
206: unsigned normalized:1;
207: unsigned expanded:2;
208: unsigned coef:1;
209: pointer arg[1];
210: } *FNODE;
211:
212: #define NEWFNODE(a,b) \
213: ((a)=(FNODE)MALLOC(sizeof(struct oFNODE)+sizeof(pointer)*(b-1)))
214:
215: typedef struct oSNODE {
216: sid id;
217: int ln;
218: pointer arg[1];
219: } *SNODE;
220:
221: #define NEWSNODE(a,b) \
222: ((a)=(SNODE)MALLOC(sizeof(struct oSNODE)+sizeof(pointer)*(b-1)),(a)->ln=asir_infile->ln)
223:
224: typedef struct oPVI {
225: int pv;
226: NODE index;
227: } *PVI;
228:
229: struct ftab {
230: char *name;
231: void (*f)();
232: int argc;
233: unsigned int quote;
234: };
235:
236: struct wtab {
237: V v;
238: int w;
239: };
240:
241:
242: #define MKPVI(a,b,c)\
243: ((a)=(pointer)MALLOC(sizeof(struct oPVI)),((PVI)(a))->pv=(b),((PVI)(a))->index=(c))
244:
245: #define FA0(f) ((f)->arg[0])
246: #define FA1(f) ((f)->arg[1])
247: #define FA2(f) ((f)->arg[2])
248: #define FA3(f) ((f)->arg[3])
249: #define FA4(f) ((f)->arg[4])
250: #define FA5(f) ((f)->arg[5])
251: #define FA6(f) ((f)->arg[6])
252:
253: #define ARG0(a) ((a)->body)
254: #define ARG1(a) (NEXT(a)->body)
255: #define ARG2(a) (NEXT(NEXT(a))->body)
256: #define ARG3(a) (NEXT(NEXT(NEXT(a)))->body)
257: #define ARG4(a) (NEXT(NEXT(NEXT(NEXT((a)))))->body)
258: #define ARG5(a) (NEXT(NEXT(NEXT(NEXT(NEXT((a))))))->body)
259: #define ARG6(a) (NEXT(NEXT(NEXT(NEXT(NEXT(NEXT((a)))))))->body)
260: #define ARG7(a) (NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT((a))))))))->body)
261: #define ARG8(a) (NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT((a)))))))))->body)
262: #define ARG9(a) (NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT((a))))))))))->body)
263: #define ARG10(a) (NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT(NEXT((a)))))))))))->body)
264:
265: #define asir_assert(ptr,id,message)\
266: switch ( id ) {\
267: case O_N: case O_P: case O_R:\
268: if( (ptr) && (OID(ptr) > (id)) ) {\
269: fprintf(stderr,message);\
270: error(" : invalid argument");\
271: }\
272: break;\
273: case O_DP:\
274: if( (ptr) && (OID(ptr) != (id)) ) {\
275: fprintf(stderr,message);\
276: error(" : invalid argument");\
277: }\
278: break;\
279: default:\
280: if( !(ptr) || (OID(ptr) != (id)) ) {\
281: fprintf(stderr,message);\
282: error(" : invalid argument");\
283: }\
284: break;\
285: }
286:
287: #define DEFSIZE 32
288: #define PVGLOBAL(i) (((unsigned long)(i))|(1<<30))
289: #define PVMGLOBAL(i) (((unsigned long)(i))|(2<<30))
290: #define PVPATTERN(i) (((unsigned long)(i))|(3<<30))
291: #define PVATTR(i) (((unsigned long)(i))>>30)
292: #define PVIND(i) (((unsigned long)(i))&0x3fffffff)
293: #define GETPV(i,p) \
294: (PVATTR(i)==0?(long)((p)=CPVS->va[(unsigned int)(i)].priv)\
295: :PVATTR(i)==1?(long)((p)=GPVS->va[PVIND(i)].priv)\
296: :PVATTR(i)==2?(long)((p)=MPVS->va[PVIND(i)].priv)\
297: :(long)((p)=PPVS->va[PVIND(i)].priv))
298:
299: #define GETPVREF(i,p) \
300: (PVATTR(i)==0?(long)((p)=&(CPVS->va[(unsigned long)(i)].priv))\
301: :PVATTR(i)==1?(long)((p)=&(GPVS->va[PVIND(i)].priv))\
302: :PVATTR(i)==2?(long)((p)=&(MPVS->va[PVIND(i)].priv))\
303: :(long)((p)=&(PPVS->va[PVIND(i)].priv)))
304:
305: #define GETPVNAME(i,p) \
306: (PVATTR(i)==0?(long)((p)=CPVS->va[(unsigned long)(i)].name)\
307: :PVATTR(i)==1?(long)((p)=GPVS->va[PVIND(i)].name)\
308: :PVATTR(i)==2?(long)((p)=MPVS->va[PVIND(i)].name)\
309: :(long)((p)=PPVS->va[PVIND(i)].name))
310:
311: #define ASSPV(i,p) \
312: (PVATTR(i)==0?(long)(CPVS->va[(unsigned long)(i)].priv=(pointer)(p))\
313: :PVATTR(i)==1?(long)(GPVS->va[PVIND(i)].priv=(pointer)(p))\
314: :PVATTR(i)==2?(long)(MPVS->va[PVIND(i)].priv=(pointer)(p))\
315: :(long)(PPVS->va[PVIND(i)].priv=(pointer)(p)))
316:
1.8 ! noro 317: #define GETPV2(i,p,pvs) \
! 318: (PVATTR(i)==0?(long)((p)=pvs->va[(unsigned int)(i)].priv)\
! 319: :PVATTR(i)==1?(long)((p)=GPVS->va[PVIND(i)].priv)\
! 320: :PVATTR(i)==2?(long)((p)=MPVS->va[PVIND(i)].priv)\
! 321: :(long)((p)=PPVS->va[PVIND(i)].priv))
! 322:
! 323: #define GETPVREF2(i,p,pvs) \
! 324: (PVATTR(i)==0?(long)((p)=&(pvs->va[(unsigned long)(i)].priv))\
! 325: :PVATTR(i)==1?(long)((p)=&(GPVS->va[PVIND(i)].priv))\
! 326: :PVATTR(i)==2?(long)((p)=&(MPVS->va[PVIND(i)].priv))\
! 327: :(long)((p)=&(PPVS->va[PVIND(i)].priv)))
! 328:
! 329: #define GETPVNAME2(i,p,pvs) \
! 330: (PVATTR(i)==0?(long)((p)=pvs->va[(unsigned long)(i)].name)\
! 331: :PVATTR(i)==1?(long)((p)=GPVS->va[PVIND(i)].name)\
! 332: :PVATTR(i)==2?(long)((p)=MPVS->va[PVIND(i)].name)\
! 333: :(long)((p)=PPVS->va[PVIND(i)].name))
! 334:
! 335: #define ASSPV2(i,p,pvs) \
! 336: (PVATTR(i)==0?(long)(pvs->va[(unsigned long)(i)].priv=(pointer)(p))\
! 337: :PVATTR(i)==1?(long)(GPVS->va[PVIND(i)].priv=(pointer)(p))\
! 338: :PVATTR(i)==2?(long)(MPVS->va[PVIND(i)].priv=(pointer)(p))\
! 339: :(long)(PPVS->va[PVIND(i)].priv=(pointer)(p)))
! 340:
! 341:
1.1 noro 342:
343: extern VS GPVS,CPVS,EPVS,APVS,MPVS,PPVS;
344: extern MODULE CUR_MODULE;
345: extern NODE MODULE_LIST;
346: extern char *CUR_FUNC;
347: extern ARF addfs, subfs, mulfs, divfs, remfs, pwrfs;
348: extern INFILE asir_infile;
349: extern NODE usrf,sysf,noargsysf,ubinf,parif,ONENODE;
350: extern int nextbp,nextbplevel;
351: extern int Verbose;
352: extern int do_quiet;
353: extern SYMBOL Symbol_grlex, Symbol_glex, Symbol_lex;
354: extern NODE current_option;
355:
356: #if defined(VISUAL_LIB)
357: #include <w_stdio.h>
358: #undef getc
359: #define getc w_fgetc
360: #undef putc
361: #define putc w_fputc
362: #define fputc w_fputc
363: #define ungetc w_ungetc
364: #define fgets w_fgets
365: #define fputs w_fputs
366: #define printf w_printf
367: #define fprintf w_fprintf
368: #define fflush w_fflush
369: #endif
370:
371: #if defined(__GNUC__) || defined(VISUAL) || defined(__MINGW32__) || (defined(__MACH__) && defined(__ppc__)) || defined(__FreeBSD__)
372: NODE mknode(int,...);
373: FNODE mkfnode(int,fid,...);
374: SNODE mksnode(int,sid,...);
375: void call_usrf(FUNC f,...);
376: #else
377: NODE mknode();
378: FNODE mkfnode();
379: SNODE mksnode();
380: void call_usrf();
381: #endif
382:
383: /* prototypes */
384:
385: void dp_vtod(Q *,DP,DP *);
386: void dp_idivv_hist(Q,DP *);
387: void dp_igcdv_hist(DP,Q *);
388: void dp_ptozp3(DP,Z *,DP *);
389: void dp_ptozp2(DP,DP,DP *,DP *);
390: void dp_ptozp(DP,DP *);
391: void dp_nf_tab_mod(DP,LIST *,int,DP *);
392: void dp_lnf_mod(DP,DP,NODE,int,DP *,DP *);
393: void insert_to_node(DL,NODE *,int);
394: int _dl_redble(DL,DL,int);
395: void dp_mbase(NODE,NODE *);
396: void dp_dtov(DP,VECT *);
397: void dp_cont(DP,Z *);
398: void dp_idiv(DP,Z,DP *);
399: void dtodpm(DP d,int pos,DPM *dp);
1.5 noro 400: void dpm_nf_z(NODE b,DPM g,VECT ps,int full,int multiple,DPM *rp);
401: void dpm_nf_f(NODE b,DPM g,VECT ps,int full,DPM *rp);
1.1 noro 402: void weyl_actd(VL vl,DP p1,DP p2,DP *pr);
1.4 noro 403: void dpm_sp(DPM p1,DPM p2,DPM *rp,DP *mul1,DP *mul2);
1.1 noro 404: void initdpm(struct order_spec *spec,int type);
405: void dpm_ht(DPM p,DPM *rp);
406: void dpm_hm(DPM p,DPM *rp);
407:
408: int dp_nt(DP);
409: void dp_dehomo(DP,DP *);
410: void dp_homo(DP,DP *);
411: DL lcm_of_DL(int,DL,DL,DL);
412: void dp_rest(DP,DP *);
413: void dp_hm(DP,DP *);
414: void dp_sp_mod(DP,DP,int,DP *);
415: void dp_sp(DP,DP,DP *);
416: void dp_red(DP,DP,DP,DP *,DP *,P *,DP *);
417: void dp_subd(DP,DP,DP *);
418: void dp_red_mod(DP,DP,DP,int,DP *,DP *,P *);
419: int dp_redble(DP,DP);
420: int comp_nm(Q *,Q *);
421: void dp_true_nf_mod(NODE,DP,DP *,int,int,DP *,P *);
422: void dp_nf_mod(NODE,DP,DP *,int,int,DP *);
423: void dp_nf_mod_qindex(NODE,DP,DP *,int,int,DP *);
424: void dp_nf_ptozp(NODE,DP,DP *,int,int,DP *);
425: void dp_nf(NODE,DP,DP *,int,DP *);
426: void dp_rat(DP,DP *);
427: void dp_mod(DP,int,NODE,DP *);
428: void dp_prim_mod(DP,int,DP *);
429: void dp_prim(DP,DP *);
430: void heu_nezgcdnpz(VL,P *,int,P *);
431: void homogenize_order(struct order_spec *,int,struct order_spec **);
432: int create_order_spec(VL,Obj,struct order_spec **);
433:
434: int dl_equal(int,DL,DL);
435: void qltozl(Q *,int,Z *);
436:
437: int mainparse(SNODE *);
438: int exprparse(FUNC,char *,FNODE *);
439: void output_init(void);
440: void GC_init(void);
441: void env_init(void);
442: void soutput_init(char *);
443: void appendparif(NODE *,char *,int (*)(),int);
444: int mmono(P);
445: void mkpow(VL,Obj,Obj,Obj *);
446: void _printdp(DP);
447: int mt_save(char *);
448: int mt_load(char *);
449: void sortbynm(Q *,int);
450: void iqrv(VECT,Z,LIST *);
451: void cpp_main(int,char **);
452: int afternl(void);
453: void glob_init();
454: void input_init(FILE *,char *);
455: void asir_terminate(int);
456: void param_init(void);
457: void sprompt(char *);
458: void cppname_init();
459: void process_args(int,char **);
460: void sig_init(void);
461: void asir_save_handler(void);
462: void asir_set_handler(void);
463: void asir_reset_handler(void);
464: void resetenv(char *);
465: void fatal(int);
466: void restore_handler(void);
467: void resize_buffer(void);
468: void tty_init(void);
469: void tty_reset(void);
470: void set_timer(int);
471: void reset_timer(void);
472: void int_handler(int);
473: void segv_handler(int);
474: void bus_handler(int);
475: void fpe_handler(int);
476: void ill_handler(int);
477: void winch_handler(int);
478: void pipe_handler(int);
479: void usr1_handler(int);
480: void alrm_handler(int);
481: void ox_usr1_handler(int sig);
482: void copyright(void);
483: void kan_init(void);
484: void pushpvs(FUNC);
485: void read_eval_loop(void);
486: void prompt(void);
487: void storeans(pointer);
488: int yyparse(void);
489: void nodetod(NODE,DP *);
490: void poppvs(void);
491: int length(NODE);
492: size_t get_heapsize(void);
493: int searchpvar(char *);
494: void searchuf(char *name,FUNC *r);
495: void mkparif(char *,FUNC *);
496: void makevar(char *,P *);
497: void mkpvs(char *);
498: MODULE mkmodule(char *);
499: void stoarg(char *,int *,char **);
500: void yyerror(char *);
501: void closecurrentinput(void);
502: void asir_terminate(int);
503: void searchasirpath(char *,char **);
504: void get_vars(Obj,VL *);
505: void appendbinf(NODE *,char *,void(*)(),int,unsigned int);
506: void appendubinf(char *,void(*)(),int,unsigned int);
507: void parif_init(void);
508: void sysf_init(void);
509: void makesrvar(FUNC, P *);
510: void sprintexpr(VL,Obj);
511: void printexpr(VL,Obj);
512: void appendvar(VL,V);
513: void change_mvar(VL,P,V,P *);
514: void restore_mvar(VL,P,V,P *);
515: int argc(NODE);
516: // void printn(N);
517: // void sprintn(N);
518: void printv(VL,V);
519: void sprintv(VL,V);
520: int arf_comp(VL, Obj, Obj);
521: int complist(VL, LIST, LIST);
522: int getcompsize(int);
523: int getpvar(VS,char *,int);
524: int gettype(unsigned int);
525: int indextotype(int,int);
526: int loadfile(char *);
527: int loadfiles(NODE);
528: unsigned int makepvar(char *);
529: int membertoindex(int,char *);
530: int qcoefp(Obj);
531: int qcoefr(Obj);
532: int rangecheck(Obj,int);
533: int structtoindex(char *);
534: void _mkpfins(PF ,Obj *,V *);
535: void appendpfins(V ,V *);
536: void appenduf(char *,FUNC *);
537: void arf_add(VL, Obj, Obj, Obj *);
538: void arf_chsgn(Obj, Obj *);
539: void arf_div(VL, Obj, Obj, Obj *);
540: void arf_init(void);
541: void arf_mul(VL, Obj, Obj, Obj *);
542: void arf_pwr(VL, Obj, Obj, Obj *);
543: void arf_remain(VL, Obj, Obj, Obj *);
544: void arf_sub(VL, Obj, Obj, Obj *);
545: void bp(SNODE);
546: void clearbp(FUNC);
547: void debug(SNODE);
548: void debug_init(void);
549: void delbp(int, char **);
550: void derivr(VL ,Obj ,V ,Obj *);
551: void derivvar(VL ,V ,V ,Obj *);
552: void duppfins(V ,V *);
553: void error(char *);
554: void evalins(PFINS ,int ,Obj *);
555: void evalnodebody(NODE,NODE *);
556: void evalp(VL ,P ,int ,P *);
557: void evalr(VL ,Obj ,int ,Obj *);
558: void evalv(VL ,V ,int ,Obj *);
559: void getarrayp(Obj,NODE,Obj **);
560: void getmember(FNODE,Obj *);
561: void getmemberp(FNODE,Obj **);
562: void help(char *);
563: void instov(PFINS ,V *);
564: Obj memberofstruct(COMP,char *);
1.7 kondoh 565: #if defined(INTERVAL)
566: void mkpf(char *,Obj ,int ,V *,int (*)(),double (*)(),int (*)(),void (*[])(), PF *);
567: #else
568: void mkpf(char *,Obj ,int ,V *,int (*)(),double (*)(),int (*)(), PF *);
569: #endif
1.1 noro 570: void mkpfins(PF ,V *,V *);
571: void mkuf(char *,char *,NODE,SNODE,int,int,char *,MODULE);
572: void newstruct(int,struct oCOMP **);
573: void optobj(Obj *);
574: void println(int, char **, int);
575: void printvars(char *,VS);
576: void resetpvs(void);
577: void searchc(char *,FUNC *);
578: void searchf(NODE,char *,FUNC *);
579: void searchpf(char *,FUNC *);
580: void searchsn(SNODE *, int, SNODE **);
581: void setbp(char *);
582: void setf(int, char **);
583: void setstruct(char *,NODE);
584: void showbp(int);
585: void showbps(void);
586: void showpos(void);
587: void simplify_ins(PFINS ,Obj *);
588: void sprintvars(char *,VS);
589: int structdef(char *,NODE);
590: void substfp(VL ,Obj ,PF ,PF ,Obj *);
591: void substfr(VL ,Obj ,PF ,PF ,Obj *);
592: void substfv(VL ,V ,PF ,PF ,Obj *);
593: void substpr(VL ,int ,Obj ,V ,Obj ,Obj *);
594: void substr(VL ,int ,Obj ,V ,Obj ,Obj *);
595: void appendtonode(NODE,pointer, NODE *);
596: void getarray(pointer,NODE,pointer *);
597: void putarray(pointer,NODE,pointer);
598:
599: void addcomp(VL,COMP,COMP,COMP *);
600: void subcomp(VL,COMP,COMP,COMP *);
601: void mulcomp(VL,COMP,COMP,COMP *);
602: void divcomp(VL,COMP,COMP,COMP *);
603: void chsgncomp(COMP,COMP *);
604: void pwrcomp(VL,COMP,Obj,COMP *);
605: int compcomp(VL,COMP,COMP);
606:
607: void mergedeglist(NODE d0,NODE d1,NODE *dr);
608: void getdeglist(P p,V v,NODE *d);
609: void restore_mvar(VL vl,P p,V v,P *r);
610: void change_mvar(VL vl,P p,V v,P *r);
611: void getcoef(VL vl,P p,V v,Z d,P *r);
612: void ranp(int n,UP *nr);
613:
614: void _print_mp(int nv,MP m);
615: int dp_homogeneous(DP p);
616: int dp_nt(DP p);
617: int dl_equal(int nv,DL dl1,DL dl2);
618: DL lcm_of_DL(int nv,DL dl1,DL dl2,DL dl);
619: void dp_rest(DP p,DP *rp);
620: void dp_hm(DP p,DP *rp);
621: void dltod(DL d,int n,DP *rp);
622: void dp_subd(DP p1,DP p2,DP *rp);
623: int dp_redble(DP p1,DP p2);
624: void sortbynm(Q *w,int n);
625: int comp_nm(Q *a,Q *b);
626: void dp_rat(DP p,DP *rp);
627: void dp_mod(DP p,int mod,NODE subst,DP *rp);
628: void dp_dehomo(DP p,DP *rp);
629: void dp_homo(DP p,DP *rp);
630: void dp_nf_tab_mod(DP p,LIST *tab,int mod,DP *rp);
631: void dp_lnf_mod(DP p1,DP p2,NODE g,int mod,DP *r1p,DP *r2p);
632: void dp_lnf_f(DP p1,DP p2,NODE g,DP *r1p,DP *r2p);
633: void _dp_nf_mod_destructive(NODE b,DP g,DP *ps,int mod,int full,DP *rp);
634: void dp_true_nf_mod(NODE b,DP g,DP *ps,int mod,int full,DP *rp,P *dnp);
635: void dp_nf_mod(NODE b,DP g,DP *ps,int mod,int full,DP *rp);
636: void dp_nf_f(NODE b,DP g,DP *ps,int full,DP *rp);
637: void dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *rp);
638: void _dp_red_mod_destructive(DP p1,DP p2,int mod,DP *rp);
639: void dp_red_mod(DP p0,DP p1,DP p2,int mod,DP *head,DP *rest,P *dnp);
640: void dp_red_f(DP p1,DP p2,DP *rest);
641: void dp_red(DP p0,DP p1,DP p2,DP *head,DP *rest,P *dnp,DP *multp);
642: void _dp_sp_mod(DP p1,DP p2,int mod,DP *rp);
643: void _dp_sp_mod_dup(DP p1,DP p2,int mod,DP *rp);
644: void dp_sp_mod(DP p1,DP p2,int mod,DP *rp);
645: void _dp_sp_dup(DP p1,DP p2,DP *rp);
646: void dp_sp(DP p1,DP p2,DP *rp);
647: void dp_dtov(DP dp,VECT *rp);
648: void dp_prim_mod(DP p,int mod,DP *rp);
649: void heu_nezgcdnpz(VL vl,P *pl,int m,P *pr);
650: void dp_prim(DP p,DP *rp);
651: void dp_vtod(Q *c,DP p,DP *rp);
652: void insert_to_node(DL d,NODE *n,int nvar);
653: int _dl_redble(DL d1,DL d2,int nvar);
654: void dp_mbase(NODE hlist,NODE *mbase);
655: void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp);
656: void dp_ptozp(DP p,DP *rp);
657: void _dpmod_to_vect(DP f,DL *at,int *b);
658: void _tf_to_vect_compress(NODE tf,DL *at,CDP *b);
659: void dp_to_vect(DP f,DL *at,Q *b);
660: NODE dp_dllist(DP f);
661: NODE mul_dllist(DL d,DP f);
662: void pdl(NODE f);
663: void dp_gr_main(LIST f,LIST v,Num homo,int modular,int field,struct order_spec *ord,LIST *rp);
664: void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp);
665: void dp_f4_main(LIST f,LIST v,struct order_spec *ord,LIST *rp);
666: void dp_f4_mod_main(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp);
667: NODE gb_f4(NODE f);
668: NODE gb_f4_mod(NODE f,int m);
669: NODE gb_f4_mod_old(NODE f,int m);
670: int dpm_redble(DPM p1,DPM p2);
671:
672: int DPPlength(DP_pairs n);
673: void printdl(DL dl);
674: void pltovl(LIST l,VL *vl);
675: void makesubst(VL v,NODE *s);
676: void printsubst(NODE s);
677: void vlminus(VL v,VL w,VL *d);
678: int validhc(P a,int m,NODE s);
679: void setup_arrays(NODE f,int m,NODE *r);
680: void prim_part(DP f,int m,DP *r);
681: NODE /* of DP */ NODE_sortb_insert( DP newdp, NODE /* of DP */ nd, int dec );
682: NODE NODE_sortb( NODE node, int dec );
683: NODE /* of index */ NODE_sortbi_insert( int newdpi, NODE /* of index */ nd, int dec );
684: NODE NODE_sortbi( NODE node, int dec );
685: void reduceall(NODE in,NODE *h);
686: void reduceall_mod(NODE in,int m,NODE *h);
687: int newps(DP a,int m,NODE subst);
688: int newps_nosave(DP a,int m,NODE subst);
689: int newps_mod(DP a,int m);
690: void reducebase_dehomo(NODE f,NODE *g);
691: NODE append_one(NODE f,long n);
692: DP_pairs minp( DP_pairs d, DP_pairs *prest );
693: void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr);
694: NODE gb(NODE f,int m,NODE subst);
695: NODE gb_mod(NODE f,int m);
696: DP_pairs updpairs( DP_pairs d, NODE /* of index */ g, int t);
697: DP_pairs newpairs( NODE /* of index */ g, int t );
698: DP_pairs criterion_B( DP_pairs d, int s );
699: DP_pairs criterion_M( DP_pairs d1 );
700: int criterion_2( int dp1, int dp2 );
701: DP_pairs criterion_F( DP_pairs d1 );
702: NODE updbase(NODE g,int t);
703: NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp );
704: int dl_redble(DL dl1,DL dl2);
705: int dl_weyl_weight(DL dl);
706: int gbcheck(NODE f);
707: int membercheck(NODE f,NODE x);
708: void dp_set_flag(Obj name,Obj value);
709: void dp_make_flaglist(LIST *list);
710: void dp_save(int index,Obj p,char *prefix);
711: void dp_load(int index,DP *p);
712: int dp_load_t(int index,DP *p);
713: void init_stat();
714: void print_stat();
715: void dp_mulc_d(DP p,P c,DP *r);
716: void _dp_nf(NODE b,DP g,DP *ps,int full,DP *rp);
717: void _dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *r);
718: void dp_imul_d(DP p,Q q,DP *rp);
719: void imulv(VECT w,Q c,VECT *rp);
720: void dptoca(DP p,unsigned int **rp);
721: int yylex();
722: void purge_stdin();
723: int afternl();
724: int aftercomment();
725: int myatoi(char *s);
726: void yyerror(char *s);
727: int Egetc(FILE *fp);
728: void Eungetc(int c,FILE *fp);
1.2 noro 729: void xget_line(char *buf);
1.1 noro 730: int readline_getc();
731: void readline_ungetc();
732: char *readline_console(char *prompt);
733: void ox_usr1_handler(int sig);
734: void env_init();
735: void loadasirfile(char *name0);
736: void execasirfile(char *name);
737: void load_and_execfile(char *name);
738: int loadfile(char *s);
739: int loadfiles(NODE node);
740: unsigned char encrypt_char(unsigned char c);
741: unsigned char decrypt_char(unsigned char c);
742: void encrypt_file(char *in,char *out);
743: void decrypt_file(char *in,char *out);
744: void get_vars(Obj t,VL *vlp);
745: void get_vars_recursive(Obj obj,VL *vlp);
746: int comp_obj(Obj *a,Obj *b);
747: int generic_comp_obj(Obj *a,Obj *b);
748: void sepvect(VECT v,int d,VECT *rp);
749: int gauss_elim_mod(int **mat,int row,int col,int md);
750: // int inttorat(N c,N m,N b,int *sgnp,N *nmp,N *dnp);
751: // int intmtoratm(MAT mat,N md,MAT nm,Q *dn);
752: // int intmtoratm_q(MAT mat,N md,MAT nm,Q *dn);
753: void reduce_reducers_mod(int **mat,int row,int col,int md);
754: void pre_reduce_mod(int **mat,int row,int col,int nred,int md);
755: void reduce_sp_by_red_mod(int *sp,int **redmat,int *ind,int nred,int col,int md);
756: void red_by_compress(int m,unsigned int *p,unsigned int *r,
757: unsigned int *ri,unsigned int hc,int len);
758: void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len);
759: void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,
760: int nred,int col,int md);
761: int lu_gfmmat(GFMMAT mat,unsigned int md,int *perm);
762: int find_lhs_and_lu_mod(unsigned int **a,int row,int col,
763: unsigned int md,int **rinfo,int **cinfo);
764: void solve_by_lu_mod(int **a,int n,int md,int **b,int l,int normalize);
765: int gauss_elim_mod1(int **mat,int row,int col,int md);
766: int gauss_elim_geninv_mod(unsigned int **mat,int row,int col,int md);
767: void solve_by_lu_gfmmat(GFMMAT lu,unsigned int md,unsigned int *b,unsigned int *x);
768: void mat_to_gfmmat(MAT m,unsigned int md,GFMMAT *rp);
769: int gauss_elim_geninv_mod_swap(unsigned int **mat,int row,int col,
770: unsigned int md,unsigned int ***invmatp,int **indexp);
771: int generate_ONB_polynomial(UP2 *rp,int m,int type);
772: int _generate_irreducible_polynomial(UP2 f,int d);
773: int _generate_good_irreducible_polynomial(UP2 f,int d);
774: void printqmat(Q **mat,int row,int col);
775: void printimat(int **mat,int row,int col);
776: void ixor(Z n1,Z n2,Z *r);
777: void ior(Z n1,Z n2,Z *r);
778: void iand(Z n1,Z n2,Z *r);
779: void isqrt(Z a,Z *r);
780: void igcd_cofactor(Z a,Z b,Z *gcd,Z *ca,Z *cb);
781: int TypeT_NB_check(unsigned int m, unsigned int t);
782: int small_jacobi(int a,int m);
783: void pushpvs(FUNC f);
784: void poppvs();
785: unsigned int makepvar(char *str);
786: int searchpvar(char *str);
787: int getpvar(VS pvs,char *str,int searchonly);
788: void closecurrentinput();
789: void resetpvs();
790: void savepvs();
791: void restorepvs();
792: void storeans(pointer p);
793: void get_rootdir(char *name,int len);
794: void set_rootdir(char *name);
795: int process_id();
796: void call_exe(char *name,char **av);
797: void addquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
798: void subquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
799: void mulquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
800: void divquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
801: void pwrquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
802: void chsgnquote(QUOTE a,QUOTE *c);
803: void objtoquote(Obj a,QUOTE *c);
804: void polytoquote(P a,QUOTE *c);
805: void dptoquote(DP a,QUOTE *c);
806: void dctoquote(DCP dc,QUOTE v,QUOTE *c,int *sgn);
807: void mptoquote(MP m,int n,QUOTE *c,int *sgn);
808: void vartoquote(V v,QUOTE *c);
1.8 ! noro 809: void fnodetotree(FNODE f,VS vs,LIST *rp);
1.1 noro 810: int compfnode(FNODE f1,FNODE f2);
811: FNODE eval_pvar_in_fnode(FNODE f);
812: FNODE subst_in_fnode(FNODE f,V v,FNODE g);
813: char *get_attribute(char *key,LIST attr);
814: void treetofnode(Obj obj,FNODE *f);
815: void glob_init() ;
816: void input_init(FILE *fp,char *name);
817: void notdef(VL vl,Obj a,Obj b,Obj *c);
818: void ExitAsir() ;
819: void asir_terminate(int status);
820: void param_init() ;
821: void prompt() ;
822: void sprompt(char *ptr);
823: void process_args(int ac,char **av);
824: void sig_init() ;
825: void asir_save_handler() ;
826: void asir_set_handler() ;
827: void asir_reset_handler() ;
828: void resetenv(char *s);
829: void fatal(int n);
830: void int_handler(int sig);
831: void restore_handler() ;
832: void segv_handler(int sig);
833: void ill_handler(int sig);
834: void alrm_handler(int sig);
835: void bus_handler(int sig);
836: void fpe_handler(int sig);
837: void pipe_handler(int sig);
838: void resize_buffer();
839: void tty_init() ;
840: void tty_reset() ;
841: void set_lasterror(char *s);
842: void error(char *s);
843: void set_timer(int interval);
844: void reset_timer();
845: void copyright() ;
846: void show_debug_window(int on);
847: void init_cmdwin();
848: void searchpf(char *name,FUNC *fp);
849: void searchc(char *name,FUNC *fp);
1.7 kondoh 850: #if defined(INTERVAL)
1.1 noro 851: void mkpf(char *name,Obj body,int argc,V *args,
1.7 kondoh 852: int (*parif)(),double (*libmf)(), int (*simp)(), void (*intervalfunc[])(), PF *pfp);
853: #else
854: void mkpf(char *name,Obj body,int argc,V *args,
855: int (*parif)(),double (*libmf)(), int (*simp)(), PF *pfp);
856: #endif
1.1 noro 857: void mkpfins(PF pf,V *args,V *vp);
858: void _mkpfins(PF pf,Obj *args,V *vp);
859: void _mkpfins_with_darray(PF pf,Obj *args,int *darray,V *vp);
860: void appendpfins(V v,V *vp);
861: void duppfins(V v,V *vp);
862: void derivvar(VL vl,V pf,V v,Obj *a);
863: void derivr(VL vl,Obj a,V v,Obj *b);
864: void substr(VL vl,int partial,Obj a,V v,Obj b,Obj *c);
865: void substpr(VL vl,int partial,Obj p,V v0,Obj p0,Obj *pr);
866: void evalr(VL vl,Obj a,int prec,Obj *c);
867: void evalp(VL vl,P p,int prec,P *pr);
868: void evalv(VL vl,V v,int prec,Obj *rp);
869: void evalins(PFINS ins,int prec,Obj *rp);
870: void devalr(VL vl,Obj a,Obj *c);
871: void devalp(VL vl,P p,P *pr);
872: void devalv(VL vl,V v,Obj *rp);
873: void devalins(PFINS ins,Obj *rp);
874: void simplify_ins(PFINS ins,Obj *rp);
875: void instov(PFINS ins,V *vp);
876: void substfr(VL vl,Obj a,PF u,PF f,Obj *c);
877: void substfp(VL vl,Obj p,PF u,PF f,Obj *pr);
878: void substfv(VL vl,V v,PF u,PF f,Obj *c);
879: int structdef(char *name,NODE member);
880: void newstruct(int type,COMP *rp);
881: int structtoindex(char *name);
882: int membertoindex(int type,char *name);
883: int getcompsize(int type);
884: Obj memberofstruct(COMP a,char *name);
885: void assign_to_member(COMP a,char *name,Obj obj);
886: void node_concat_dup(NODE n1,NODE n2,NODE *nr);
887: pointer evall(lid id,Obj a1,Obj a2);
888: pointer eval(FNODE f);
889: pointer evalstat(SNODE f);
890: pointer evalnode(NODE node);
891: pointer evalf(FUNC f,FNODE a,FNODE opt);
892: pointer evalparif(FUNC f,NODE a);
893: pointer evalf_deriv(FUNC f,FNODE a,FNODE deriv);
894: pointer evalmapf(FUNC f,FNODE a);
895: pointer eval_rec_mapf(FUNC f,FNODE a);
896: pointer beval_rec_mapf(FUNC f,NODE node);
897: pointer bevalf(FUNC f,NODE a);
898: pointer bevalf_with_opts(FUNC f,NODE a,NODE opts);
899: pointer evalif(FNODE f,FNODE a,FNODE opt);
900: pointer evalpf(PF pf,NODE args,NODE deriv);
901: void evalnodebody(NODE sn,NODE *dnp);
902: void gen_searchf(char *name,FUNC *r);
903: void gen_searchf_searchonly(char *name,FUNC *r,int global);
904: void searchf(NODE fn,char *name,FUNC *r);
905: void appenduf(char *name,FUNC *r);
906: void mkparif(char *name,FUNC *r);
907: void mkuf(char *name,char *fname,NODE args,SNODE body,int startl,int endl,char *desc,MODULE module);
908: Obj getopt_from_cpvs(char *key);
909: void des_enc(unsigned long *, unsigned char *, unsigned long *);
910: unsigned long round_func(unsigned long , unsigned char *);
911: unsigned long s_box_func(unsigned char *);
912: void des_dec(unsigned long *, unsigned char *, unsigned long *);
913: void key_schedule(unsigned char *,unsigned char *);
914: void debug_init();
915: void add_alias(char *com,char *alias);
916: void show_alias(char *alias);
917: void debug(SNODE f);
918: void setf(int ac,char **av);
919: void setbp(char *p);
920: void settp(char *p);
921: void clearbp(FUNC f);
922: int searchbp();
923: void delbp(int ac,char **av);
924: void showbps();
925: void showbp(int n);
926: void searchsn(SNODE *fp,int n,SNODE **fpp);
927: void bp(SNODE f);
928: void println(int ac,char **av,int l);
929: void printvars(char *s,VS vs);
930: void showpos();
931: void showpos_to_string(char *buf);
932: void change_stack(int level,NODE *pvss);
933: void show_stack(VS vs);
934: int estimate_length(VL vl,pointer p);
935: void send_progress(short per,char *msg);
936: void set_error(int code,char *reason,char *action);
937: double get_current_time();
938: void mp_abs(NODE arg,Num *rp);
939: int get_opt(char *key0,Obj *r);
940:
941: #if defined(VISUAL) || defined(__MINGW32__)
1.3 ohara 942: void ox_plot_main();
1.1 noro 943: #else
944: void ox_plot_main(int argc,char **argv);
945: #endif
946: void launch_main(int argc,char **argv);
947: void ox_main(int argc,char **argv);
948: void order_init();
949: void print_crossref(FUNC f);
950: void showpos_to_list(LIST *r);
951: void update_LASTCO();
952:
953: void get_fid_spec(fid id,fid_spec_p *spec);
954: FNODE strip_paren(FNODE f);
955: NODE flatten_fnodenode(NODE n,char *opname);
956: FNODE flatten_fnode(FNODE f,char *opname);
957: int compquote(VL vl,QUOTE q1,QUOTE q2);
958: int compqa(VL vl,QUOTEARG q1,QUOTEARG q2);
959: int compfnode(FNODE f1,FNODE f2);
960: void shuffle_mulnbp(VL vl,NBP p1,NBP p2, NBP *rp);
961: void harmonic_mulnbp(VL vl,NBP p1,NBP p2, NBP *rp);
962: void mulnbmnbp(VL vl,NBM m,NBP p, NBP *rp);
963: void mulnbpnbm(VL vl,NBP p,NBM m, NBP *rp);
964: P separate_nbm(NBM a,NBP *a0,NBP *ah,NBP *ar);
965: P separate_tail_nbm(NBM a,NBP *a0,NBP *ar,NBP *at);
966: P separate_xky_nbm(NBM a,NBP *a0,NBP *ah,NBP *ar);
967:
968: int fnode_is_var(FNODE f);
969: int fnode_is_coef(FNODE f);
970: int fnode_is_number(FNODE f);
971: int fnode_is_rational(FNODE f);
972: int fnode_is_integer(FNODE f);
973: int fnode_is_nonnegative_integer(FNODE f);
974: int fnode_is_one(FNODE f);
975: int fnode_is_minusone(FNODE f);
976: int fnode_is_dependent(FNODE f,V v);
977:
978: int nfnode_weight(struct wtab *tab,FNODE f);
979: int nfnode_comp(FNODE f1,FNODE f2);
980: int nfnode_comp_lex(FNODE f1,FNODE f2);
981: int nfnode_match(FNODE f,FNODE pat,NODE *rp);
982: int nfnode_match_naryadd(FNODE f,FNODE p,NODE *rp);
983: int nfnode_match_narymul(FNODE f,FNODE p,NODE *rp);
984:
985: int exprparse_create_var(FUNC f,char *str,SNODE *statp);
986: int obj_is_dependent(Obj a,V v);
987: void instoobj(PFINS ins,Obj *rp);
988: void goto_toplevel(char *s);
989: void add_bucket(GeoBucket g,NODE d,int nv);
990:
991: #if defined(GC7)
992: void *GC_get_main_stack_base();
993: #else
994: void *GC_get_stack_base();
995: #endif
996:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2018 / parse