eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

SYS.DIUTIL dependencies on DIANA

Line 95: -- should have the semantics OF listtext(diana.as_list(n), ',');

91: -----------------------
92: FUNCTION idname(n ptnod) RETURN VARCHAR2 IS
93: -- RETURN the text OF an id node. this FUNCTION IS also
94: -- used TO limit the recursion IN exprtext() below.
95: -- should have the semantics OF listtext(diana.as_list(n), ',');
96: seq pidl.ptseqnd;
97: BEGIN
98: assert(pidl.ptkin(n) = diana.ds_id);
99: seq := diana.as_list(n);

Line 98: assert(pidl.ptkin(n) = diana.ds_id);

94: -- used TO limit the recursion IN exprtext() below.
95: -- should have the semantics OF listtext(diana.as_list(n), ',');
96: seq pidl.ptseqnd;
97: BEGIN
98: assert(pidl.ptkin(n) = diana.ds_id);
99: seq := diana.as_list(n);
100: RETURN coatname(diana.l_symrep(last_elt(seq)));
101: END idname;
102:

Line 99: seq := diana.as_list(n);

95: -- should have the semantics OF listtext(diana.as_list(n), ',');
96: seq pidl.ptseqnd;
97: BEGIN
98: assert(pidl.ptkin(n) = diana.ds_id);
99: seq := diana.as_list(n);
100: RETURN coatname(diana.l_symrep(last_elt(seq)));
101: END idname;
102:
103: -----------------------

Line 100: RETURN coatname(diana.l_symrep(last_elt(seq)));

96: seq pidl.ptseqnd;
97: BEGIN
98: assert(pidl.ptkin(n) = diana.ds_id);
99: seq := diana.as_list(n);
100: RETURN coatname(diana.l_symrep(last_elt(seq)));
101: END idname;
102:
103: -----------------------
104: -- exprtext: general unparsing FUNCTION

Line 133: IF (pidl.ptkin(k) <> diana.d_s_decl) THEN RETURN NULL; END IF;

129: FUNCTION procname(k ptnod) RETURN VARCHAR2 IS
130: x ptnod; xkind pidl.ptnty;
131: BEGIN
132: IF (k IS NULL OR k = 0) THEN RETURN NULL; END IF;
133: IF (pidl.ptkin(k) <> diana.d_s_decl) THEN RETURN NULL; END IF;
134: x := diana.a_d_(k);
135: xkind := pidl.ptkin(x);
136: IF ( xkind <> diana.di_funct
137: AND xkind <> diana.di_proc

Line 134: x := diana.a_d_(k);

130: x ptnod; xkind pidl.ptnty;
131: BEGIN
132: IF (k IS NULL OR k = 0) THEN RETURN NULL; END IF;
133: IF (pidl.ptkin(k) <> diana.d_s_decl) THEN RETURN NULL; END IF;
134: x := diana.a_d_(k);
135: xkind := pidl.ptkin(x);
136: IF ( xkind <> diana.di_funct
137: AND xkind <> diana.di_proc
138: AND xkind <> diana.d_def_op) THEN

Line 136: IF ( xkind <> diana.di_funct

132: IF (k IS NULL OR k = 0) THEN RETURN NULL; END IF;
133: IF (pidl.ptkin(k) <> diana.d_s_decl) THEN RETURN NULL; END IF;
134: x := diana.a_d_(k);
135: xkind := pidl.ptkin(x);
136: IF ( xkind <> diana.di_funct
137: AND xkind <> diana.di_proc
138: AND xkind <> diana.d_def_op) THEN
139: RETURN NULL;
140: END IF;

Line 137: AND xkind <> diana.di_proc

133: IF (pidl.ptkin(k) <> diana.d_s_decl) THEN RETURN NULL; END IF;
134: x := diana.a_d_(k);
135: xkind := pidl.ptkin(x);
136: IF ( xkind <> diana.di_funct
137: AND xkind <> diana.di_proc
138: AND xkind <> diana.d_def_op) THEN
139: RETURN NULL;
140: END IF;
141: RETURN diana.l_symrep(x);

Line 138: AND xkind <> diana.d_def_op) THEN

134: x := diana.a_d_(k);
135: xkind := pidl.ptkin(x);
136: IF ( xkind <> diana.di_funct
137: AND xkind <> diana.di_proc
138: AND xkind <> diana.d_def_op) THEN
139: RETURN NULL;
140: END IF;
141: RETURN diana.l_symrep(x);
142: END;

Line 141: RETURN diana.l_symrep(x);

137: AND xkind <> diana.di_proc
138: AND xkind <> diana.d_def_op) THEN
139: RETURN NULL;
140: END IF;
141: RETURN diana.l_symrep(x);
142: END;
143:
144:
145: -----------------------

Line 198: -- get_diana

194: END;
195: END get_d;
196:
197: -----------------------
198: -- get_diana
199: -----------------------
200: PROCEDURE get_diana (name VARCHAR2, usr VARCHAR2, dbname VARCHAR2,
201: dbowner VARCHAR2,
202: status IN OUT ub4, nod IN OUT ptnod,

Line 200: PROCEDURE get_diana (name VARCHAR2, usr VARCHAR2, dbname VARCHAR2,

196:
197: -----------------------
198: -- get_diana
199: -----------------------
200: PROCEDURE get_diana (name VARCHAR2, usr VARCHAR2, dbname VARCHAR2,
201: dbowner VARCHAR2,
202: status IN OUT ub4, nod IN OUT ptnod,
203: libunit_type NUMBER := libunit_type_spec,
204: load_source NUMBER := load_source_no) IS

Line 206: BEGIN -- get_diana

202: status IN OUT ub4, nod IN OUT ptnod,
203: libunit_type NUMBER := libunit_type_spec,
204: load_source NUMBER := load_source_no) IS
205: t ptnod;
206: BEGIN -- get_diana
207: nod := NULL;
208: BEGIN
209: get_d(name, usr, dbname, dbowner, status, nod,
210: libunit_type, load_source);

Line 212: t := diana.a_unit_b(nod);

208: BEGIN
209: get_d(name, usr, dbname, dbowner, status, nod,
210: libunit_type, load_source);
211: IF (status = s_ok) THEN
212: t := diana.a_unit_b(nod);
213: assert(pidl.ptkin(t) <> diana.q_create);
214: END IF;
215: EXCEPTION
216: WHEN program_error THEN

Line 213: assert(pidl.ptkin(t) <> diana.q_create);

209: get_d(name, usr, dbname, dbowner, status, nod,
210: libunit_type, load_source);
211: IF (status = s_ok) THEN
212: t := diana.a_unit_b(nod);
213: assert(pidl.ptkin(t) <> diana.q_create);
214: END IF;
215: EXCEPTION
216: WHEN program_error THEN
217: status := s_other;

Line 221: END get_diana;

217: status := s_other;
218: WHEN OTHERS THEN
219: status := s_other;
220: END;
221: END get_diana;
222:
223:
224: -----------------------
225: -- subptxt

Line 257: get_diana(name, usr, dbname, dbowner, status, troot,

253: troot ptnod;
254: n ptnod;
255: nsubname VARCHAR2(100);
256: BEGIN
257: get_diana(name, usr, dbname, dbowner, status, troot,
258: libunit_type_spec, load_source_yes);
259: IF (troot IS NULL OR troot = 0) THEN RETURN; END IF;
260:
261: nsubname := normalname(subname);

Line 262: n := diana.a_unit_b(troot);

258: libunit_type_spec, load_source_yes);
259: IF (troot IS NULL OR troot = 0) THEN RETURN; END IF;
260:
261: nsubname := normalname(subname);
262: n := diana.a_unit_b(troot);
263:
264: IF (nsubname IS NULL OR nsubname = '') THEN
265: IF ((pidl.ptkin(n) = diana.d_p_decl) OR
266: (pidl.ptkin(n) = diana.d_library)) THEN

Line 265: IF ((pidl.ptkin(n) = diana.d_p_decl) OR

261: nsubname := normalname(subname);
262: n := diana.a_unit_b(troot);
263:
264: IF (nsubname IS NULL OR nsubname = '') THEN
265: IF ((pidl.ptkin(n) = diana.d_p_decl) OR
266: (pidl.ptkin(n) = diana.d_library)) THEN
267: diustx(troot, txt, status);
268: ELSE
269: describeproc(n, txt);

Line 266: (pidl.ptkin(n) = diana.d_library)) THEN

262: n := diana.a_unit_b(troot);
263:
264: IF (nsubname IS NULL OR nsubname = '') THEN
265: IF ((pidl.ptkin(n) = diana.d_p_decl) OR
266: (pidl.ptkin(n) = diana.d_library)) THEN
267: diustx(troot, txt, status);
268: ELSE
269: describeproc(n, txt);
270: END IF;

Line 273: IF (pidl.ptkin(n) <> diana.d_p_decl) THEN

269: describeproc(n, txt);
270: END IF;
271: ELSE
272: -- search FOR subname among ALL func/proc IN the PACKAGE
273: IF (pidl.ptkin(n) <> diana.d_p_decl) THEN
274: status := s_subpnotfound;
275: RETURN;
276: END IF;
277: n := diana.a_packag(n);

Line 277: n := diana.a_packag(n);

273: IF (pidl.ptkin(n) <> diana.d_p_decl) THEN
274: status := s_subpnotfound;
275: RETURN;
276: END IF;
277: n := diana.a_packag(n);
278: DECLARE
279: seq pidl.ptseqnd := diana.as_list(diana.as_decl1(n));
280: len INTEGER := pidl.ptslen(seq) - 1;
281: tmp INTEGER;

Line 279: seq pidl.ptseqnd := diana.as_list(diana.as_decl1(n));

275: RETURN;
276: END IF;
277: n := diana.a_packag(n);
278: DECLARE
279: seq pidl.ptseqnd := diana.as_list(diana.as_decl1(n));
280: len INTEGER := pidl.ptslen(seq) - 1;
281: tmp INTEGER;
282: BEGIN
283: FOR i IN 0..len LOOP --FOR each MEMBER OF the PACKAGE

Line 350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b

346: BEGIN
347: IF (n IS NOT NULL) THEN
348: nkind := pidl.ptkin(n);
349: -- simple expr
350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b
351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in

Line 351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct

347: IF (n IS NOT NULL) THEN
348: nkind := pidl.ptkin(n);
349: -- simple expr
350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b
351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN

Line 352: OR nkind = diana.di_proc OR nkind = diana.di_packa

348: nkind := pidl.ptkin(n);
349: -- simple expr
350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b
351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));

Line 353: OR nkind = diana.di_var OR nkind = diana.di_type

349: -- simple expr
350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b
351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));
357:

Line 354: OR nkind = diana.di_subty OR nkind = diana.di_in

350: IF (nkind = diana.di_u_nam OR nkind = diana.d_used_b
351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));
357:
358: ELSIF (nkind = diana.d_s_ed) THEN

Line 355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN

351: OR nkind = diana.di_u_blt OR nkind = diana.di_funct
352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));
357:
358: ELSIF (nkind = diana.d_s_ed) THEN
359: -- x.y

Line 356: rv := rv || coatname(diana.l_symrep(n));

352: OR nkind = diana.di_proc OR nkind = diana.di_packa
353: OR nkind = diana.di_var OR nkind = diana.di_type
354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));
357:
358: ELSIF (nkind = diana.d_s_ed) THEN
359: -- x.y
360: etext(diana.a_name(n));

Line 358: ELSIF (nkind = diana.d_s_ed) THEN

354: OR nkind = diana.di_subty OR nkind = diana.di_in
355: OR nkind = diana.di_out OR nkind = diana.di_in_ou) THEN
356: rv := rv || coatname(diana.l_symrep(n));
357:
358: ELSIF (nkind = diana.d_s_ed) THEN
359: -- x.y
360: etext(diana.a_name(n));
361: rv := rv || '.';
362: etext(diana.a_d_char(n));

Line 360: etext(diana.a_name(n));

356: rv := rv || coatname(diana.l_symrep(n));
357:
358: ELSIF (nkind = diana.d_s_ed) THEN
359: -- x.y
360: etext(diana.a_name(n));
361: rv := rv || '.';
362: etext(diana.a_d_char(n));
363:
364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c

Line 362: etext(diana.a_d_char(n));

358: ELSIF (nkind = diana.d_s_ed) THEN
359: -- x.y
360: etext(diana.a_name(n));
361: rv := rv || '.';
362: etext(diana.a_d_char(n));
363:
364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c
365: OR nkind = diana.d_def_op) THEN
366: rv := rv || '''' || diana.l_symrep(n) || '''';

Line 364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c

360: etext(diana.a_name(n));
361: rv := rv || '.';
362: etext(diana.a_d_char(n));
363:
364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c
365: OR nkind = diana.d_def_op) THEN
366: rv := rv || '''' || diana.l_symrep(n) || '''';
367:
368: ELSIF (nkind = diana.d_attrib) THEN

Line 365: OR nkind = diana.d_def_op) THEN

361: rv := rv || '.';
362: etext(diana.a_d_char(n));
363:
364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c
365: OR nkind = diana.d_def_op) THEN
366: rv := rv || '''' || diana.l_symrep(n) || '''';
367:
368: ELSIF (nkind = diana.d_attrib) THEN
369: -- x.y%TYPE

Line 366: rv := rv || '''' || diana.l_symrep(n) || '''';

362: etext(diana.a_d_char(n));
363:
364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c
365: OR nkind = diana.d_def_op) THEN
366: rv := rv || '''' || diana.l_symrep(n) || '''';
367:
368: ELSIF (nkind = diana.d_attrib) THEN
369: -- x.y%TYPE
370: -- simply ADD the %TYPE text rather than try TO resolve

Line 368: ELSIF (nkind = diana.d_attrib) THEN

364: ELSIF (nkind = diana.d_string OR nkind = diana.d_used_c
365: OR nkind = diana.d_def_op) THEN
366: rv := rv || '''' || diana.l_symrep(n) || '''';
367:
368: ELSIF (nkind = diana.d_attrib) THEN
369: -- x.y%TYPE
370: -- simply ADD the %TYPE text rather than try TO resolve
371: -- it TO get the name OF the TYPE
372: --

Line 373: etext(diana.a_name(n));

369: -- x.y%TYPE
370: -- simply ADD the %TYPE text rather than try TO resolve
371: -- it TO get the name OF the TYPE
372: --
373: etext(diana.a_name(n));
374: rv := rv || '%';
375: etext(diana.a_id(n));
376:
377: ELSIF (nkind = diana.d_numeri) THEN

Line 375: etext(diana.a_id(n));

371: -- it TO get the name OF the TYPE
372: --
373: etext(diana.a_name(n));
374: rv := rv || '%';
375: etext(diana.a_id(n));
376:
377: ELSIF (nkind = diana.d_numeri) THEN
378: rv := rv || diana.l_numrep(n);
379:

Line 377: ELSIF (nkind = diana.d_numeri) THEN

373: etext(diana.a_name(n));
374: rv := rv || '%';
375: etext(diana.a_id(n));
376:
377: ELSIF (nkind = diana.d_numeri) THEN
378: rv := rv || diana.l_numrep(n);
379:
380: ELSIF (nkind = diana.d_null_a) THEN
381: rv := rv || 'null';

Line 378: rv := rv || diana.l_numrep(n);

374: rv := rv || '%';
375: etext(diana.a_id(n));
376:
377: ELSIF (nkind = diana.d_numeri) THEN
378: rv := rv || diana.l_numrep(n);
379:
380: ELSIF (nkind = diana.d_null_a) THEN
381: rv := rv || 'null';
382:

Line 380: ELSIF (nkind = diana.d_null_a) THEN

376:
377: ELSIF (nkind = diana.d_numeri) THEN
378: rv := rv || diana.l_numrep(n);
379:
380: ELSIF (nkind = diana.d_null_a) THEN
381: rv := rv || 'null';
382:
383: ELSIF (nkind = diana.d_constr) THEN -- constraint
384: etext(diana.a_name(n));

Line 383: ELSIF (nkind = diana.d_constr) THEN -- constraint

379:
380: ELSIF (nkind = diana.d_null_a) THEN
381: rv := rv || 'null';
382:
383: ELSIF (nkind = diana.d_constr) THEN -- constraint
384: etext(diana.a_name(n));
385: -- -- Function params and returns do not accept constraints directly.
386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
387: -- rv := rv || ' ';

Line 384: etext(diana.a_name(n));

380: ELSIF (nkind = diana.d_null_a) THEN
381: rv := rv || 'null';
382:
383: ELSIF (nkind = diana.d_constr) THEN -- constraint
384: etext(diana.a_name(n));
385: -- -- Function params and returns do not accept constraints directly.
386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
387: -- rv := rv || ' ';
388: -- etext(diana.a_constt(n));

Line 386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN

382:
383: ELSIF (nkind = diana.d_constr) THEN -- constraint
384: etext(diana.a_name(n));
385: -- -- Function params and returns do not accept constraints directly.
386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
387: -- rv := rv || ' ';
388: -- etext(diana.a_constt(n));
389: -- END IF;
390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN

Line 388: -- etext(diana.a_constt(n));

384: etext(diana.a_name(n));
385: -- -- Function params and returns do not accept constraints directly.
386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
387: -- rv := rv || ' ';
388: -- etext(diana.a_constt(n));
389: -- END IF;
390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
391: RAISE e_notv6compat;
392: END IF;

Line 390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN

386: -- IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
387: -- rv := rv || ' ';
388: -- etext(diana.a_constt(n));
389: -- END IF;
390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
391: RAISE e_notv6compat;
392: END IF;
393: IF (diana.a_cs(n) IS NOT NULL) THEN
394: IF ((diana.s_charset_form(diana.a_cs(n)) = 1) OR

Line 393: IF (diana.a_cs(n) IS NOT NULL) THEN

389: -- END IF;
390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
391: RAISE e_notv6compat;
392: END IF;
393: IF (diana.a_cs(n) IS NOT NULL) THEN
394: IF ((diana.s_charset_form(diana.a_cs(n)) = 1) OR
395: (diana.s_charset_form(diana.a_cs(n)) = 4)) THEN
396: -- SQLCS_IMPLICIT: don't need to mark anything.
397: -- SQLCS_FLEXIBLE: for now, don't mark anything. If we ever

Line 394: IF ((diana.s_charset_form(diana.a_cs(n)) = 1) OR

390: IF (diana.a_constt(n) IS NOT NULL AND diana.a_constt(n) <> 0) THEN
391: RAISE e_notv6compat;
392: END IF;
393: IF (diana.a_cs(n) IS NOT NULL) THEN
394: IF ((diana.s_charset_form(diana.a_cs(n)) = 1) OR
395: (diana.s_charset_form(diana.a_cs(n)) = 4)) THEN
396: -- SQLCS_IMPLICIT: don't need to mark anything.
397: -- SQLCS_FLEXIBLE: for now, don't mark anything. If we ever
398: -- need to support v8 clients, for those we'd want marking.

Line 395: (diana.s_charset_form(diana.a_cs(n)) = 4)) THEN

391: RAISE e_notv6compat;
392: END IF;
393: IF (diana.a_cs(n) IS NOT NULL) THEN
394: IF ((diana.s_charset_form(diana.a_cs(n)) = 1) OR
395: (diana.s_charset_form(diana.a_cs(n)) = 4)) THEN
396: -- SQLCS_IMPLICIT: don't need to mark anything.
397: -- SQLCS_FLEXIBLE: for now, don't mark anything. If we ever
398: -- need to support v8 clients, for those we'd want marking.
399: NULL;

Line 413: ELSIF (nkind = diana.d_parm_c) THEN

409: -- 14jul92 =g=> many OF these remaining cases BY an work,
410: -- but aren't needed.
411:
412: -- implicit conversion
413: ELSIF (nkind = diana.d_parm_c) THEN
414: DECLARE seq pidl.ptseqnd := diana.as_list(diana.as_p_ass(n));
415: BEGIN
416: etext(last_elt(seq));
417: END;

Line 414: DECLARE seq pidl.ptseqnd := diana.as_list(diana.as_p_ass(n));

410: -- but aren't needed.
411:
412: -- implicit conversion
413: ELSIF (nkind = diana.d_parm_c) THEN
414: DECLARE seq pidl.ptseqnd := diana.as_list(diana.as_p_ass(n));
415: BEGIN
416: etext(last_elt(seq));
417: END;
418:

Line 420: ELSIF (nkind = diana.ds_apply) THEN

416: etext(last_elt(seq));
417: END;
418:
419: -- arglist
420: ELSIF (nkind = diana.ds_apply) THEN
421: DECLARE aseq ptnod := diana.as_list(n); BEGIN
422: rv := rv || '(';
423: listtext(aseq, ',');
424: rv := rv || ')';

Line 421: DECLARE aseq ptnod := diana.as_list(n); BEGIN

417: END;
418:
419: -- arglist
420: ELSIF (nkind = diana.ds_apply) THEN
421: DECLARE aseq ptnod := diana.as_list(n); BEGIN
422: rv := rv || '(';
423: listtext(aseq, ',');
424: rv := rv || ')';
425: END;

Line 428: ELSIF (nkind = diana.d_f_call) THEN

424: rv := rv || ')';
425: END;
426:
427: -- d_f_call
428: ELSIF (nkind = diana.d_f_call) THEN
429: DECLARE args ptnod := diana.as_p_ass(n);
430: BEGIN
431: IF (pidl.ptkin(args) <> diana.ds_param) THEN
432: -- ordinary function call

Line 429: DECLARE args ptnod := diana.as_p_ass(n);

425: END;
426:
427: -- d_f_call
428: ELSIF (nkind = diana.d_f_call) THEN
429: DECLARE args ptnod := diana.as_p_ass(n);
430: BEGIN
431: IF (pidl.ptkin(args) <> diana.ds_param) THEN
432: -- ordinary function call
433: etext(diana.a_name(n));

Line 431: IF (pidl.ptkin(args) <> diana.ds_param) THEN

427: -- d_f_call
428: ELSIF (nkind = diana.d_f_call) THEN
429: DECLARE args ptnod := diana.as_p_ass(n);
430: BEGIN
431: IF (pidl.ptkin(args) <> diana.ds_param) THEN
432: -- ordinary function call
433: etext(diana.a_name(n));
434: etext(args);
435: ELSE -- operator functions, determine if unary or n-ary

Line 433: etext(diana.a_name(n));

429: DECLARE args ptnod := diana.as_p_ass(n);
430: BEGIN
431: IF (pidl.ptkin(args) <> diana.ds_param) THEN
432: -- ordinary function call
433: etext(diana.a_name(n));
434: etext(args);
435: ELSE -- operator functions, determine if unary or n-ary
436: DECLARE s pidl.ptseqnd := diana.as_list(args);
437: namenode ptnod := diana.a_name(n);

Line 436: DECLARE s pidl.ptseqnd := diana.as_list(args);

432: -- ordinary function call
433: etext(diana.a_name(n));
434: etext(args);
435: ELSE -- operator functions, determine if unary or n-ary
436: DECLARE s pidl.ptseqnd := diana.as_list(args);
437: namenode ptnod := diana.a_name(n);
438: BEGIN
439: IF (pidl.ptslen(s) = 1) THEN -- unary
440: etext(namenode);

Line 437: namenode ptnod := diana.a_name(n);

433: etext(diana.a_name(n));
434: etext(args);
435: ELSE -- operator functions, determine if unary or n-ary
436: DECLARE s pidl.ptseqnd := diana.as_list(args);
437: namenode ptnod := diana.a_name(n);
438: BEGIN
439: IF (pidl.ptslen(s) = 1) THEN -- unary
440: etext(namenode);
441: rv := rv || ' ';

Line 452: ELSIF (nkind = diana.d_parent) THEN

448:
449: -- parenthesized expr
450: -- whenever this gets uncommented, we must fully support the
451: -- D_F_CALL case as well (Usha - 6/28/95)
452: ELSIF (nkind = diana.d_parent) THEN
453: rv := rv || '(';
454: etext(diana.a_exp(n));
455: rv := rv || ')';
456:

Line 454: etext(diana.a_exp(n));

450: -- whenever this gets uncommented, we must fully support the
451: -- D_F_CALL case as well (Usha - 6/28/95)
452: ELSIF (nkind = diana.d_parent) THEN
453: rv := rv || '(';
454: etext(diana.a_exp(n));
455: rv := rv || ')';
456:
457: -- binary logical operation
458: ELSIF (nkind = diana.d_binary) THEN

Line 458: ELSIF (nkind = diana.d_binary) THEN

454: etext(diana.a_exp(n));
455: rv := rv || ')';
456:
457: -- binary logical operation
458: ELSIF (nkind = diana.d_binary) THEN
459: etext(diana.a_exp1(n));
460: rv := rv || ' ';
461: etext(diana.a_binary(n));
462: rv := rv || ' ';

Line 459: etext(diana.a_exp1(n));

455: rv := rv || ')';
456:
457: -- binary logical operation
458: ELSIF (nkind = diana.d_binary) THEN
459: etext(diana.a_exp1(n));
460: rv := rv || ' ';
461: etext(diana.a_binary(n));
462: rv := rv || ' ';
463: etext(diana.a_exp2(n));

Line 461: etext(diana.a_binary(n));

457: -- binary logical operation
458: ELSIF (nkind = diana.d_binary) THEN
459: etext(diana.a_exp1(n));
460: rv := rv || ' ';
461: etext(diana.a_binary(n));
462: rv := rv || ' ';
463: etext(diana.a_exp2(n));
464: ELSIF (nkind = diana.d_and_th) THEN
465: rv := rv || 'and';

Line 463: etext(diana.a_exp2(n));

459: etext(diana.a_exp1(n));
460: rv := rv || ' ';
461: etext(diana.a_binary(n));
462: rv := rv || ' ';
463: etext(diana.a_exp2(n));
464: ELSIF (nkind = diana.d_and_th) THEN
465: rv := rv || 'and';
466: ELSIF (nkind = diana.d_or_els) THEN
467: rv := rv || 'or';

Line 464: ELSIF (nkind = diana.d_and_th) THEN

460: rv := rv || ' ';
461: etext(diana.a_binary(n));
462: rv := rv || ' ';
463: etext(diana.a_exp2(n));
464: ELSIF (nkind = diana.d_and_th) THEN
465: rv := rv || 'and';
466: ELSIF (nkind = diana.d_or_els) THEN
467: rv := rv || 'or';
468:

Line 466: ELSIF (nkind = diana.d_or_els) THEN

462: rv := rv || ' ';
463: etext(diana.a_exp2(n));
464: ELSIF (nkind = diana.d_and_th) THEN
465: rv := rv || 'and';
466: ELSIF (nkind = diana.d_or_els) THEN
467: rv := rv || 'or';
468:
469: ELSIF (nkind = diana.ds_id) THEN -- idList
470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.

Line 469: ELSIF (nkind = diana.ds_id) THEN -- idList

465: rv := rv || 'and';
466: ELSIF (nkind = diana.d_or_els) THEN
467: rv := rv || 'or';
468:
469: ELSIF (nkind = diana.ds_id) THEN -- idList
470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
471: DECLARE seq pidl.ptseqnd := diana.as_list(n);
472: BEGIN
473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));

Line 470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.

466: ELSIF (nkind = diana.d_or_els) THEN
467: rv := rv || 'or';
468:
469: ELSIF (nkind = diana.ds_id) THEN -- idList
470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
471: DECLARE seq pidl.ptseqnd := diana.as_list(n);
472: BEGIN
473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));
474: END;

Line 471: DECLARE seq pidl.ptseqnd := diana.as_list(n);

467: rv := rv || 'or';
468:
469: ELSIF (nkind = diana.ds_id) THEN -- idList
470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
471: DECLARE seq pidl.ptseqnd := diana.as_list(n);
472: BEGIN
473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));
474: END;
475:

Line 473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));

469: ELSIF (nkind = diana.ds_id) THEN -- idList
470: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
471: DECLARE seq pidl.ptseqnd := diana.as_list(n);
472: BEGIN
473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));
474: END;
475:
476: ELSIF (nkind = diana.ds_d_ran) THEN
477: DECLARE seq pidl.ptseqnd := diana.as_list(n);

Line 476: ELSIF (nkind = diana.ds_d_ran) THEN

472: BEGIN
473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));
474: END;
475:
476: ELSIF (nkind = diana.ds_d_ran) THEN
477: DECLARE seq pidl.ptseqnd := diana.as_list(n);
478: x ptnod;
479: BEGIN
480: x := last_elt(seq);

Line 477: DECLARE seq pidl.ptseqnd := diana.as_list(n);

473: rv := rv || coatname(diana.l_symrep(last_elt(seq)));
474: END;
475:
476: ELSIF (nkind = diana.ds_d_ran) THEN
477: DECLARE seq pidl.ptseqnd := diana.as_list(n);
478: x ptnod;
479: BEGIN
480: x := last_elt(seq);
481: etext(diana.a_name(x));

Line 481: etext(diana.a_name(x));

477: DECLARE seq pidl.ptseqnd := diana.as_list(n);
478: x ptnod;
479: BEGIN
480: x := last_elt(seq);
481: etext(diana.a_name(x));
482: END;
483:
484: -- declarations
485: ELSIF (nkind = diana.d_var OR nkind = diana.d_consta) THEN

Line 485: ELSIF (nkind = diana.d_var OR nkind = diana.d_consta) THEN

481: etext(diana.a_name(x));
482: END;
483:
484: -- declarations
485: ELSIF (nkind = diana.d_var OR nkind = diana.d_consta) THEN
486: -- var and const
487: etext(diana.as_id(n));
488: rv := rv || ' ';
489: IF (nkind = diana.d_consta) THEN

Line 487: etext(diana.as_id(n));

483:
484: -- declarations
485: ELSIF (nkind = diana.d_var OR nkind = diana.d_consta) THEN
486: -- var and const
487: etext(diana.as_id(n));
488: rv := rv || ' ';
489: IF (nkind = diana.d_consta) THEN
490: rv := rv || 'constant ';
491: END IF;

Line 489: IF (nkind = diana.d_consta) THEN

485: ELSIF (nkind = diana.d_var OR nkind = diana.d_consta) THEN
486: -- var and const
487: etext(diana.as_id(n));
488: rv := rv || ' ';
489: IF (nkind = diana.d_consta) THEN
490: rv := rv || 'constant ';
491: END IF;
492: etext(diana.a_type_s(n));
493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN

Line 492: etext(diana.a_type_s(n));

488: rv := rv || ' ';
489: IF (nkind = diana.d_consta) THEN
490: rv := rv || 'constant ';
491: END IF;
492: etext(diana.a_type_s(n));
493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN
494: rv := rv || ' := ';
495: etext(diana.a_object(n));
496: ELSE assert(nkind <> diana.d_consta);

Line 493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN

489: IF (nkind = diana.d_consta) THEN
490: rv := rv || 'constant ';
491: END IF;
492: etext(diana.a_type_s(n));
493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN
494: rv := rv || ' := ';
495: etext(diana.a_object(n));
496: ELSE assert(nkind <> diana.d_consta);
497: END IF;

Line 495: etext(diana.a_object(n));

491: END IF;
492: etext(diana.a_type_s(n));
493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN
494: rv := rv || ' := ';
495: etext(diana.a_object(n));
496: ELSE assert(nkind <> diana.d_consta);
497: END IF;
498:
499: ELSIF (nkind = diana.d_intege) THEN

Line 496: ELSE assert(nkind <> diana.d_consta);

492: etext(diana.a_type_s(n));
493: IF (diana.a_object(n) IS NOT NULL AND diana.a_object(n) <> 0) THEN
494: rv := rv || ' := ';
495: etext(diana.a_object(n));
496: ELSE assert(nkind <> diana.d_consta);
497: END IF;
498:
499: ELSIF (nkind = diana.d_intege) THEN
500: etext(diana.a_range(n));

Line 499: ELSIF (nkind = diana.d_intege) THEN

495: etext(diana.a_object(n));
496: ELSE assert(nkind <> diana.d_consta);
497: END IF;
498:
499: ELSIF (nkind = diana.d_intege) THEN
500: etext(diana.a_range(n));
501: ELSIF (nkind = diana.d_range) THEN
502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN
503: -- in case of array single index;

Line 500: etext(diana.a_range(n));

496: ELSE assert(nkind <> diana.d_consta);
497: END IF;
498:
499: ELSIF (nkind = diana.d_intege) THEN
500: etext(diana.a_range(n));
501: ELSIF (nkind = diana.d_range) THEN
502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN
503: -- in case of array single index;
504: rv := rv || 'range ';

Line 501: ELSIF (nkind = diana.d_range) THEN

497: END IF;
498:
499: ELSIF (nkind = diana.d_intege) THEN
500: etext(diana.a_range(n));
501: ELSIF (nkind = diana.d_range) THEN
502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN
503: -- in case of array single index;
504: rv := rv || 'range ';
505: etext(diana.a_exp1(n));

Line 502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN

498:
499: ELSIF (nkind = diana.d_intege) THEN
500: etext(diana.a_range(n));
501: ELSIF (nkind = diana.d_range) THEN
502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN
503: -- in case of array single index;
504: rv := rv || 'range ';
505: etext(diana.a_exp1(n));
506: rv := rv || '..';

Line 505: etext(diana.a_exp1(n));

501: ELSIF (nkind = diana.d_range) THEN
502: IF (diana.a_exp1(n) IS NOT NULL AND diana.a_exp1(n) <> 0) THEN
503: -- in case of array single index;
504: rv := rv || 'range ';
505: etext(diana.a_exp1(n));
506: rv := rv || '..';
507: END IF;
508: etext(diana.a_exp2(n));
509:

Line 508: etext(diana.a_exp2(n));

504: rv := rv || 'range ';
505: etext(diana.a_exp1(n));
506: rv := rv || '..';
507: END IF;
508: etext(diana.a_exp2(n));
509:
510: ELSIF (nkind = diana.d_type) THEN -- type declaration
511: rv := rv || 'type ';
512: etext(diana.a_id(n));

Line 510: ELSIF (nkind = diana.d_type) THEN -- type declaration

506: rv := rv || '..';
507: END IF;
508: etext(diana.a_exp2(n));
509:
510: ELSIF (nkind = diana.d_type) THEN -- type declaration
511: rv := rv || 'type ';
512: etext(diana.a_id(n));
513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN
514: rv := rv || ' is ';

Line 512: etext(diana.a_id(n));

508: etext(diana.a_exp2(n));
509:
510: ELSIF (nkind = diana.d_type) THEN -- type declaration
511: rv := rv || 'type ';
512: etext(diana.a_id(n));
513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN
514: rv := rv || ' is ';
515: etext(diana.a_type_s(n));
516: END IF;

Line 513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN

509:
510: ELSIF (nkind = diana.d_type) THEN -- type declaration
511: rv := rv || 'type ';
512: etext(diana.a_id(n));
513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN
514: rv := rv || ' is ';
515: etext(diana.a_type_s(n));
516: END IF;
517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration

Line 515: etext(diana.a_type_s(n));

511: rv := rv || 'type ';
512: etext(diana.a_id(n));
513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN
514: rv := rv || ' is ';
515: etext(diana.a_type_s(n));
516: END IF;
517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration
518: rv := rv || 'subtype ';
519: etext(diana.a_id(n));

Line 517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration

513: IF (diana.a_type_s(n) IS NOT NULL AND diana.a_type_s(n) <> 0) THEN
514: rv := rv || ' is ';
515: etext(diana.a_type_s(n));
516: END IF;
517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration
518: rv := rv || 'subtype ';
519: etext(diana.a_id(n));
520: rv := rv || ' is ';
521: etext(diana.a_constd(n));

Line 519: etext(diana.a_id(n));

515: etext(diana.a_type_s(n));
516: END IF;
517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration
518: rv := rv || 'subtype ';
519: etext(diana.a_id(n));
520: rv := rv || ' is ';
521: etext(diana.a_constd(n));
522: ELSIF (nkind = diana.d_r_) THEN -- record type
523: rv := rv || 'record (';

Line 521: etext(diana.a_constd(n));

517: ELSIF (nkind = diana.d_subtyp) THEN -- subtype declaration
518: rv := rv || 'subtype ';
519: etext(diana.a_id(n));
520: rv := rv || ' is ';
521: etext(diana.a_constd(n));
522: ELSIF (nkind = diana.d_r_) THEN -- record type
523: rv := rv || 'record (';
524: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
525: DECLARE seq pidl.ptseqnd := diana.as_list(n);

Line 522: ELSIF (nkind = diana.d_r_) THEN -- record type

518: rv := rv || 'subtype ';
519: etext(diana.a_id(n));
520: rv := rv || ' is ';
521: etext(diana.a_constd(n));
522: ELSIF (nkind = diana.d_r_) THEN -- record type
523: rv := rv || 'record (';
524: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
525: DECLARE seq pidl.ptseqnd := diana.as_list(n);
526: BEGIN

Line 524: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.

520: rv := rv || ' is ';
521: etext(diana.a_constd(n));
522: ELSIF (nkind = diana.d_r_) THEN -- record type
523: rv := rv || 'record (';
524: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
525: DECLARE seq pidl.ptseqnd := diana.as_list(n);
526: BEGIN
527: listtext(seq, ', ');
528: END;

Line 525: DECLARE seq pidl.ptseqnd := diana.as_list(n);

521: etext(diana.a_constd(n));
522: ELSIF (nkind = diana.d_r_) THEN -- record type
523: rv := rv || 'record (';
524: -- listText(diana.as_list(n), ','); causes PL/SQL Check #21037.
525: DECLARE seq pidl.ptseqnd := diana.as_list(n);
526: BEGIN
527: listtext(seq, ', ');
528: END;
529: rv := rv || ')';

Line 530: ELSIF (nkind = diana.d_array) THEN

526: BEGIN
527: listtext(seq, ', ');
528: END;
529: rv := rv || ')';
530: ELSIF (nkind = diana.d_array) THEN
531: rv := rv || 'table of ';
532: etext(diana.a_name(diana.a_constd(n)));
533: rv := rv || '(';
534: etext(diana.a_constt(diana.a_constd(n)));

Line 532: etext(diana.a_name(diana.a_constd(n)));

528: END;
529: rv := rv || ')';
530: ELSIF (nkind = diana.d_array) THEN
531: rv := rv || 'table of ';
532: etext(diana.a_name(diana.a_constd(n)));
533: rv := rv || '(';
534: etext(diana.a_constt(diana.a_constd(n)));
535: rv := rv || ') indexed by ';
536: etext(diana.as_dscrt(n));

Line 534: etext(diana.a_constt(diana.a_constd(n)));

530: ELSIF (nkind = diana.d_array) THEN
531: rv := rv || 'table of ';
532: etext(diana.a_name(diana.a_constd(n)));
533: rv := rv || '(';
534: etext(diana.a_constt(diana.a_constd(n)));
535: rv := rv || ') indexed by ';
536: etext(diana.as_dscrt(n));
537: ELSIF (nkind = diana.d_except) THEN
538: etext(diana.as_id(n));

Line 536: etext(diana.as_dscrt(n));

532: etext(diana.a_name(diana.a_constd(n)));
533: rv := rv || '(';
534: etext(diana.a_constt(diana.a_constd(n)));
535: rv := rv || ') indexed by ';
536: etext(diana.as_dscrt(n));
537: ELSIF (nkind = diana.d_except) THEN
538: etext(diana.as_id(n));
539: rv := rv || ' exception';
540:

Line 537: ELSIF (nkind = diana.d_except) THEN

533: rv := rv || '(';
534: etext(diana.a_constt(diana.a_constd(n)));
535: rv := rv || ') indexed by ';
536: etext(diana.as_dscrt(n));
537: ELSIF (nkind = diana.d_except) THEN
538: etext(diana.as_id(n));
539: rv := rv || ' exception';
540:
541: */

Line 538: etext(diana.as_id(n));

534: etext(diana.a_constt(diana.a_constd(n)));
535: rv := rv || ') indexed by ';
536: etext(diana.as_dscrt(n));
537: ELSIF (nkind = diana.d_except) THEN
538: etext(diana.as_id(n));
539: rv := rv || ' exception';
540:
541: */
542:

Line 643: stext := stext || idname(diana.as_id(k)) || ' ';

639: stext := stext || ' (';
640: FOR i IN 1 .. parmnum LOOP
641: k := pidl.ptgend(parmseq, i-1);
642: assert(k IS NOT NULL);
643: stext := stext || idname(diana.as_id(k)) || ' ';
644: knd := pidl.ptkin(k);
645: IF (knd = diana.d_out) THEN
646: stext := stext || 'out ';
647: ELSIF (knd = diana.d_in_out) THEN

Line 645: IF (knd = diana.d_out) THEN

641: k := pidl.ptgend(parmseq, i-1);
642: assert(k IS NOT NULL);
643: stext := stext || idname(diana.as_id(k)) || ' ';
644: knd := pidl.ptkin(k);
645: IF (knd = diana.d_out) THEN
646: stext := stext || 'out ';
647: ELSIF (knd = diana.d_in_out) THEN
648: stext := stext || 'in out ';
649: ELSE

Line 647: ELSIF (knd = diana.d_in_out) THEN

643: stext := stext || idname(diana.as_id(k)) || ' ';
644: knd := pidl.ptkin(k);
645: IF (knd = diana.d_out) THEN
646: stext := stext || 'out ';
647: ELSIF (knd = diana.d_in_out) THEN
648: stext := stext || 'in out ';
649: ELSE
650: assert(knd = diana.d_in);
651: END IF;

Line 650: assert(knd = diana.d_in);

646: stext := stext || 'out ';
647: ELSIF (knd = diana.d_in_out) THEN
648: stext := stext || 'in out ';
649: ELSE
650: assert(knd = diana.d_in);
651: END IF;
652: exprtext(diana.a_name(k), stext);
653: IF 0 < instr(flags, '6') AND NOT is_v6_type(diana.a_name(k)) THEN
654: RAISE e_notv6compat;

Line 652: exprtext(diana.a_name(k), stext);

648: stext := stext || 'in out ';
649: ELSE
650: assert(knd = diana.d_in);
651: END IF;
652: exprtext(diana.a_name(k), stext);
653: IF 0 < instr(flags, '6') AND NOT is_v6_type(diana.a_name(k)) THEN
654: RAISE e_notv6compat;
655: END IF;
656:

Line 653: IF 0 < instr(flags, '6') AND NOT is_v6_type(diana.a_name(k)) THEN

649: ELSE
650: assert(knd = diana.d_in);
651: END IF;
652: exprtext(diana.a_name(k), stext);
653: IF 0 < instr(flags, '6') AND NOT is_v6_type(diana.a_name(k)) THEN
654: RAISE e_notv6compat;
655: END IF;
656:
657: k := diana.a_exp_vo(k);

Line 657: k := diana.a_exp_vo(k);

653: IF 0 < instr(flags, '6') AND NOT is_v6_type(diana.a_name(k)) THEN
654: RAISE e_notv6compat;
655: END IF;
656:
657: k := diana.a_exp_vo(k);
658: IF (k IS NOT NULL AND k <> 0) THEN
659: hasdefval := true;
660: IF defvaloption = defvaloption_full THEN
661: stext := stext || ' := ';

Line 684: leftchild := diana.a_d_(n);

680: -- generate a procedure declaration into sText spec
681:
682: returnval := '';
683: assert(n IS NOT NULL);
684: leftchild := diana.a_d_(n);
685: assert(leftchild IS NOT NULL);
686: nodekind := pidl.ptkin(leftchild);
687:
688: rightchild := diana.a_header(n);

Line 688: rightchild := diana.a_header(n);

684: leftchild := diana.a_d_(n);
685: assert(leftchild IS NOT NULL);
686: nodekind := pidl.ptkin(leftchild);
687:
688: rightchild := diana.a_header(n);
689: IF (nodekind = diana.di_funct OR nodekind = diana.d_def_op) THEN
690: stext := stext || 'function ';
691: returntypenode := diana.a_name_v(rightchild);
692: exprtext(returntypenode, returnval);

Line 689: IF (nodekind = diana.di_funct OR nodekind = diana.d_def_op) THEN

685: assert(leftchild IS NOT NULL);
686: nodekind := pidl.ptkin(leftchild);
687:
688: rightchild := diana.a_header(n);
689: IF (nodekind = diana.di_funct OR nodekind = diana.d_def_op) THEN
690: stext := stext || 'function ';
691: returntypenode := diana.a_name_v(rightchild);
692: exprtext(returntypenode, returnval);
693: -- ?? returnVal := substr(exprText(diana.a_name_v(rightChild)), 1, 511);

Line 691: returntypenode := diana.a_name_v(rightchild);

687:
688: rightchild := diana.a_header(n);
689: IF (nodekind = diana.di_funct OR nodekind = diana.d_def_op) THEN
690: stext := stext || 'function ';
691: returntypenode := diana.a_name_v(rightchild);
692: exprtext(returntypenode, returnval);
693: -- ?? returnVal := substr(exprText(diana.a_name_v(rightChild)), 1, 511);
694: ELSE
695: stext := stext || 'procedure ';

Line 693: -- ?? returnVal := substr(exprText(diana.a_name_v(rightChild)), 1, 511);

689: IF (nodekind = diana.di_funct OR nodekind = diana.d_def_op) THEN
690: stext := stext || 'function ';
691: returntypenode := diana.a_name_v(rightchild);
692: exprtext(returntypenode, returnval);
693: -- ?? returnVal := substr(exprText(diana.a_name_v(rightChild)), 1, 511);
694: ELSE
695: stext := stext || 'procedure ';
696: returnval := NULL;
697: assert(nodekind = diana.di_proc);

Line 697: assert(nodekind = diana.di_proc);

693: -- ?? returnVal := substr(exprText(diana.a_name_v(rightChild)), 1, 511);
694: ELSE
695: stext := stext || 'procedure ';
696: returnval := NULL;
697: assert(nodekind = diana.di_proc);
698: END IF;
699: IF (pname IS NULL) THEN
700: exprtext(leftchild, pname);
701: END IF;

Line 704: rightchild := diana.as_p_(rightchild);

700: exprtext(leftchild, pname);
701: END IF;
702: stext := stext || pname;
703:
704: rightchild := diana.as_p_(rightchild);
705: assert(rightchild IS NOT NULL);
706: genparmtext(diana.as_list(rightchild));
707:
708: IF (returnval IS NOT NULL) THEN

Line 706: genparmtext(diana.as_list(rightchild));

702: stext := stext || pname;
703:
704: rightchild := diana.as_p_(rightchild);
705: assert(rightchild IS NOT NULL);
706: genparmtext(diana.as_list(rightchild));
707:
708: IF (returnval IS NOT NULL) THEN
709: IF 0 < instr(flags, '6') AND NOT is_v6_type(returntypenode)
710: THEN RAISE e_notv6compat;

Line 760: -- libunit_node : legal ptnod, as returned by get_diana or get_d

756: -- node_use_statistics: reports libunit's node count and limit
757: --
758: -- Parameters:
759: --
760: -- libunit_node : legal ptnod, as returned by get_diana or get_d
761: -- node_count : how many diana nodes the unit contains
762: -- node_limit : that many diana nodes allowed to allocate
763: --
764: procedure node_use_statistics (libunit_node IN ptnod,

Line 761: -- node_count : how many diana nodes the unit contains

757: --
758: -- Parameters:
759: --
760: -- libunit_node : legal ptnod, as returned by get_diana or get_d
761: -- node_count : how many diana nodes the unit contains
762: -- node_limit : that many diana nodes allowed to allocate
763: --
764: procedure node_use_statistics (libunit_node IN ptnod,
765: node_count out ub4,

Line 762: -- node_limit : that many diana nodes allowed to allocate

758: -- Parameters:
759: --
760: -- libunit_node : legal ptnod, as returned by get_diana or get_d
761: -- node_count : how many diana nodes the unit contains
762: -- node_limit : that many diana nodes allowed to allocate
763: --
764: procedure node_use_statistics (libunit_node IN ptnod,
765: node_count out ub4,
766: node_limit out ub4)

Line 776: -- libunit_node : legal ptnod, as returned by get_diana or get_d

772: -- attribute_use_statistics: reports libunit's attribute count and limit
773: --
774: -- Parameters:
775: --
776: -- libunit_node : legal ptnod, as returned by get_diana or get_d
777: -- attribute_count : how many diana attributes the unit contains
778: -- attribute_limit : that many diana attributes allowed to allocate
779: --
780: procedure attribute_use_statistics (libunit_node IN ptnod,

Line 777: -- attribute_count : how many diana attributes the unit contains

773: --
774: -- Parameters:
775: --
776: -- libunit_node : legal ptnod, as returned by get_diana or get_d
777: -- attribute_count : how many diana attributes the unit contains
778: -- attribute_limit : that many diana attributes allowed to allocate
779: --
780: procedure attribute_use_statistics (libunit_node IN ptnod,
781: attribute_count out ub4,

Line 778: -- attribute_limit : that many diana attributes allowed to allocate

774: -- Parameters:
775: --
776: -- libunit_node : legal ptnod, as returned by get_diana or get_d
777: -- attribute_count : how many diana attributes the unit contains
778: -- attribute_limit : that many diana attributes allowed to allocate
779: --
780: procedure attribute_use_statistics (libunit_node IN ptnod,
781: attribute_count out ub4,
782: attribute_limit out ub4)