From 8f1e0435cca1d97caba2da1e306432ace45d0bbd Mon Sep 17 00:00:00 2001 From: guez Date: Tue, 8 Apr 2008 13:43:01 +0000 Subject: Version 1.1 de xinput-ivy, auteur Philippe Ribet --- Makefile | 24 + calibration.e | 106 + debian/changelog | 16 + debian/compat | 1 + debian/control | 15 + debian/copyright | 10 + debian/dirs | 1 + debian/docs | 0 debian/install | 1 + debian/rules | 73 + reference_points.e | 103 + wacom_pointer.e | 426 ++ xinput_ivy.c | 20921 +++++++++++++++++++++++++++++++++++++++++++++++++++ xinput_ivy.e | 431 ++ xinput_ivy.h | 3249 ++++++++ 15 files changed, 25377 insertions(+) create mode 100644 Makefile create mode 100644 calibration.e create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100644 debian/copyright create mode 100644 debian/dirs create mode 100644 debian/docs create mode 100644 debian/install create mode 100755 debian/rules create mode 100644 reference_points.e create mode 100644 wacom_pointer.e create mode 100644 xinput_ivy.c create mode 100644 xinput_ivy.e create mode 100644 xinput_ivy.h diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5ab2b76 --- /dev/null +++ b/Makefile @@ -0,0 +1,24 @@ +APPNAME=xinput_ivy +SRC=${APPNAME}.c ${APPNAME}.h + +all: ${APPNAME} + +${APPNAME}: ${SRC} + ${SHELL} ${APPNAME}.make + +%.c:%.e + se c2c -boost -c_mode release $< -o ${@:.c=} + +%.h:%.c + +clean: + rm -f *~ + rm -f *.o + rm -f ${APPNAME} + +distclean: clean + se clean ${APPNAME} + +install: all + install -d ${DESTDIR}${PREFIX}/bin + install -m 0755 ${APPNAME} ${DESTDIR}${PREFIX}/bin diff --git a/calibration.e b/calibration.e new file mode 100644 index 0000000..e1b2d6a --- /dev/null +++ b/calibration.e @@ -0,0 +1,106 @@ +class CALIBRATION +-- This class is able to +-- - build some calibration grid with user assistance, +-- - save calibration grid, +-- - reload calibration grid, +-- - use calibration grid for coordinates conversion. + +create {ANY} + make + +feature {} + make is + do + create reference_points.make + end + +feature {ANY} + ready: BOOLEAN + + build (display_width_, display_height_: INTEGER) is + local + uncalibrated: FAST_ARRAY[INTEGER] + do + display_width := display_width_ + display_height := display_height_ + from + uncalibrated := {FAST_ARRAY[INTEGER] <<0, 0, display_width, display_height>>} + until + uncalibrated.is_empty + loop + + end + ensure + ready + end + + write_to (os: OUTPUT_STREAM) is + require + os.is_connected + do + ensure + os.is_connected + end + + load_from (data: INPUT_STREAM) is + require + data.is_connected + do + end + + set_offset(x_display, y_display: INTEGER) is + do + x_offset := x_display + y_offset := y_display + end + + convert (x_device, y_device: INTEGER) is + -- Result is available in last_x, last_y + require + x_device.in_range(0, device_width) + y_device.in_range(0, device_height) + local + i, j: INTEGER + x_rest, y_rest: INTEGER + + do + i := x_device // horizontal_step + j := y_device // vertical_step + x_rest := x_device - i * horizontal_step + y_rest := y_device - j * vertical_step + if y_rest * 2 < vertical_step then + last_x := ((x_table.item(i, j) * x_rest + x_table.item(i + 1, j) * (horizontal_step - x_rest)) / horizontal_step).force_to_integer_32 + else + last_x := ((x_table.item(i, j + 1) * x_rest + x_table.item(i + 1, j + 1) * (horizontal_step - x_rest)) / horizontal_step).force_to_integer_32 + end + if x_rest * 2 < horizontal_step then + last_y := ((y_table.item(i, j) * y_rest + y_table.item(i, j + 1) * (vertical_step - y_rest)) / vertical_step).force_to_integer_32 + else + last_y := ((y_table.item(i + 1, j) * y_rest + y_table.item(i + 1, j + 1) * (vertical_step - y_rest)) / vertical_step).force_to_integer_32 + end + ensure + last_x.in_range(x_offset, x_offset + display_width -1) + last_y.in_range(y_offset, y_offset + display_height - 1) + end + + last_x, last_y: INTEGER + -- Last conversion result (in display coordinates) + +feature {} + x_offset, y_offset, display_width, display_height: INTEGER + -- coordinates and size of the displayed area in pixels + + x_table, y_table: FAST_ARRAY2[REAL] + -- Store display coordinates for device coordinate. Use + -- `horizontal_step' and `vertical_step' for table indexes values. + + horizontal_step, vertical_step: INTEGER + -- Indexes steps for tables + + device_width, device_height: INTEGER + -- Digitizer size + + reference_points: REFERENCE_POINTS + -- 4 values per reference point x_device +end + diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..c621b15 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,16 @@ +xinput-ivy (1.1-1) unstable; urgency=low + + * Ajout de l'information hires (précision subpixel de la position du + pointeur). + * Ajout de l'information de proximité + * Les deux sliders sont maintenant réinitialisés à 0 lorsque le doigt + est enlevé. + * Les boutons des stylets sont reportés dans les messages. + + -- Philippe Ribet Fri, 28 Mar 2008 16:46:00 +0100 + +xinput-ivy (1.0-1) unstable; urgency=low + + * Initial Debian release + + -- Olivier Fourdan Mon, 5 Mar 2007 15:22:41 +0100 diff --git a/debian/compat b/debian/compat new file mode 100644 index 0000000..b8626c4 --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +4 diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..952dbf8 --- /dev/null +++ b/debian/control @@ -0,0 +1,15 @@ +Source: xinput-ivy +Priority: optional +Maintainer: Philippe Ribet +Build-Depends: debhelper (>= 4.0.0), xlibs-dev | libx11-dev, ivy-c-dev (>=3.9), libxi-dev | x11proto-input-dev +Standards-Version: 3.6.1 +Section: tools + +Package: xinput-ivy +Section: x11 +Architecture: any +Depends: ${misc:Depends}, ivy-c (>=3.9), libxi6 +Description: Ivy proxy for XInput + "xinput_ivy" acts as an Ivy proxy, receiving XInput events and + broadcasting corresponding Ivy messages. + Useful with Wacom Cintiq 21UX. diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 0000000..869b712 --- /dev/null +++ b/debian/copyright @@ -0,0 +1,10 @@ +This package was debianized by Olivier Fourdan on +Mon, 5 Mar 2007 15:22:41 +0100. + +Author: Philippe Ribet + +Copyright Holder: CENA + +License: + +GPL diff --git a/debian/dirs b/debian/dirs new file mode 100644 index 0000000..e772481 --- /dev/null +++ b/debian/dirs @@ -0,0 +1 @@ +usr/bin diff --git a/debian/docs b/debian/docs new file mode 100644 index 0000000..e69de29 diff --git a/debian/install b/debian/install new file mode 100644 index 0000000..1df36c6 --- /dev/null +++ b/debian/install @@ -0,0 +1 @@ +usr/bin/* diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..52d6898 --- /dev/null +++ b/debian/rules @@ -0,0 +1,73 @@ +#!/usr/bin/make -f +# -*- makefile -*- +# +# $Id$ +# + +package=xinput-ivy + +# Uncomment this to turn on verbose mode. +export DH_VERBOSE=1 + +configure: configure-stamp +configure-stamp: + dh_testdir + touch configure-stamp + +build: build-stamp +build-stamp: configure-stamp + dh_testdir + touch build-stamp + $(MAKE) DESTDIR=$(CURDIR)/debian/tmp PREFIX=/usr + +clean: + dh_testdir + dh_testroot + rm -f build-stamp configure-stamp + $(MAKE) clean + dh_clean + +install: build + dh_testdir + dh_testroot + dh_clean -k + dh_installdirs + $(MAKE) install DESTDIR=$(CURDIR)/debian/tmp PREFIX=/usr + +# Build architecture-independent files here. +binary-indep: build install +# We have nothing to do by default. + +# Build architecture-dependent files here. +binary-arch: build install + dh_testdir + dh_testroot + dh_installchangelogs +# dh_installdocs README + dh_installexamples + dh_install --source=$(CURDIR)/debian/tmp +# dh_installmenu +# dh_installdebconf +# dh_installlogrotate +# dh_installemacsen +# dh_installpam +# dh_installmime +# dh_installinit +# dh_installcron +# dh_installinfo + dh_installman + dh_link + dh_strip +# dh_compress +# dh_fixperms +# dh_perl +# dh_python +# dh_makeshlibs + dh_installdeb + dh_shlibdeps + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch +.PHONY: build clean binary-indep binary-arch binary install configure diff --git a/reference_points.e b/reference_points.e new file mode 100644 index 0000000..8059108 --- /dev/null +++ b/reference_points.e @@ -0,0 +1,103 @@ +class REFERENCE_POINTS + +insert PLATFORM + +create {CALIBRATION} + make + +feature {} + make is + do + create x_device_points.with_capacity(10) + create y_device_points.with_capacity(10) + create x_display_points.with_capacity(10) + create y_display_points.with_capacity(10) + end + +feature {ANY} + add_point(x_device, y_device, x_display, y_display: INTEGER) is + do + x_device_points.add_last(x_device) + y_device_points.add_last(y_device) + x_display_points.add_last(x_display) + y_display_points.add_last(y_display) + ensure + count = old count + 1 + end + + count: INTEGER is + do + Result := x_device_points.count + end + + find_best_pair_for(x, y: INTEGER) is + -- Find the two nearest points for (x, y) in device + -- coordinates, trying as much as possible to get one point + -- on each side. + -- + -- Note: The result can be the same point twice + local + d1, d2, d_min, tmp: INTEGER_64 + p1, p2: INTEGER + i1, i2: INTEGER + x1, y1, x2, y2: INTEGER + do + from + i1 := x_device_points.upper + d_min := Maximum_integer_64 + until + i1 < x_device_points.lower + loop + x1 := x_device_points.item(i1) + d1 := x1 - x + d1 := d1 * d1 + y1 := y_device_points.item(i1) + tmp := y1 - y + d1 := d1 + tmp * tmp + if d1 < d_min then + from + i2 := i1 - 1 + until + i2 < x_device_points.lower + loop + x2 := x_device_points.item(i2) + y2 := y_device_points.item(i2) + if ((x1 < x) xor (x2 < x)) and then + ((y1 < y) xor (y2 < y)) then + d2 := x2 - x + tmp := y2 - y + d2 := d2 * d2 + tmp * tmp + d1 + if d2 < d_min then + d_min := d2 + p1 := i1 + p2 := i2 + end + end + i2 := i2 - 1 + end + end + i1 := i1 - 1 + end + -- *** le cas où on ne peut pas trouver un point de chaque + -- coté n'est pas géré + -- *** a la fin, il faudrait renseigner last_* + end + + last_point1_x, last_point1_y: INTEGER + -- Answer point for `find_best_pair_for' + + last_point2_x, last_point2_y: INTEGER + -- Answer point for `find_best_pair_for' + +feature {} + x_device_points, y_device_points: FAST_ARRAY[INTEGER] + + x_display_points, y_display_points: FAST_ARRAY[INTEGER] + +invariant + x_display_points.count = count + y_display_points.count = count + x_device_points.count = count + y_device_points.count = count + +end diff --git a/wacom_pointer.e b/wacom_pointer.e new file mode 100644 index 0000000..1325625 --- /dev/null +++ b/wacom_pointer.e @@ -0,0 +1,426 @@ +class WACOM_POINTER + +create {XINPUT_IVY} + make, make_self_test + +feature {} + make(a_xinput_ivy: XINPUT_IVY) is + require + a_xinput_ivy /= Void + do + xinput_ivy := a_xinput_ivy + prediction_time := 25 + end + + make_self_test is + local + angle: REAL + x, y: REAL + mc: MATH_CONSTANTS + i: INTEGER + do + from + angle := 80 + prediction_time := 10 + until + i > 36 + loop + x := (angle * mc.Pi / 180).cos * 1000 + y := (angle * mc.Pi / 180).sin * 1000 + if i > 2 then + --io.put_string(once "Real position: x=") + io.put_real(x) + --io.put_string(once ", y=") + io.put_character(' ') + io.put_real(y) + io.put_new_line + end + update_predicted_position(x, y, angle) + if i >= 2 then + --io.put_string(once "Predicted position: x=") + io.put_real(predicted_x) + --io.put_string(once ", y=") + io.put_character(' ') + io.put_real(predicted_y) + io.put_character(' ') + --io.put_new_line + end + angle := angle + prediction_time + i := i + 1 + end + end + + xinput_ivy: XINPUT_IVY + + x_offset, y_offset: INTEGER + + prediction_time: REAL + + ignore_rate, ignored_counter: INTEGER + + pointer_message_header, button_message_header: STRING + + old_presure: INTEGER + + type_to_name(type_id: INTEGER): STRING is + do + inspect type_id + when 2066 then Result := once "pen_2066" -- 0x812 + when 2049 then Result := once "pen_2049" -- 0x801 + -- 0x012 + when 2082 then Result := once "pen_2082" -- 0x822 + -- 0x842 + -- 0x852 + when 2083 then Result := once "grip_pen_2083" -- 0x823 + when 2067 then Result := once "classic_pen_2067" -- 0x813 + when 2181 then Result := once "marker_pen_2181" -- 0x885 + -- 0x022 + when 2098 then Result := once "stroke_pen_2098" -- 0x832 + -- 0x032 + when 3346 then Result := once "airbrush_3346" -- 0xd12 + -- 0x912 + -- 0x112 + when 2323 then Result := once "airbrush_2323" -- 0x913 + when 2090 then Result := once "eraser_2090" -- 0x82a + -- 0x85a + -- 0x91a + -- 0xd1a + -- 0x0fa + when 2091 then Result := once "grip_pen_eraser_2091" -- 0x82b + when 2075 then Result := once "classic_pen_eraser_2075" -- 0x81b + when 2331 then Result := once "airbrush_eraser_2331" -- 0x91b + else + Result := once "" + Result.clear_count + type_id.append_in(Result) + end + end + +feature {XINPUT_IVY} + set_x_offset(offset: INTEGER) is + do + x_offset := offset + end + + set_y_offset(offset: INTEGER) is + do + y_offset := offset + end + + set_prediction(milliseconds: REAL) is + do + prediction_time := milliseconds + end + + set_ignore_rate(n: INTEGER) is + do + ignore_rate := n + end + + set_message_header(header: STRING) is + local + history_size: INTEGER + do + pointer_message_header := "pointer" + pointer_message_header.append(header) + button_message_header := "button" + button_message_header.append(header) + history_size := 1 + create x_history.make(0, history_size) + create y_history.make(0, history_size) + create time_history.make(0, history_size) + end + + device_to_screen_x(x: INTEGER): INTEGER is + do + Result := (x / 86400 * 1600 + x_offset).force_to_integer_32 -- **** geometrie paramétrable + end + + device_to_screen_y(y: INTEGER): INTEGER is + do + Result := (y / 65000 * 1200 + y_offset).force_to_integer_32 -- **** geometrie paramétrable + end + + x_history, y_history, time_history: RING_ARRAY[INTEGER] + + mean(history: RING_ARRAY[INTEGER]): REAL is + require + history.count > 0 + local + sum: INTEGER_64 + i: INTEGER + do + from + i := history.lower + until + i > history.upper + loop + sum := sum + history.item(i) + i := i + 1 + end + Result := sum / history.count + end + + move(pointer: X_INPUT_DEVICE) is + local + x, y, presure: INTEGER + t3: REAL_64 + message: STRING + do + x := pointer.motion_axis_data(1) + y := pointer.motion_axis_data(2) + --update_predicted_position(x, y, pointer.event_time) + x_history.remove_first + x_history.add_last(x) + y_history.remove_first + y_history.add_last(y) + time_history.remove_first + time_history.add_last(pointer.event_time) + t3 := mean(time_history) + if t3 /= t2 then + update_predicted_position(mean(x_history), mean(y_history), t3) + end + presure := pointer.motion_axis_data(3) + if ignored_counter < ignore_rate and then ((old_presure = 0) = (presure = 0)) then + ignored_counter := ignored_counter + 1 + else + ignored_counter := 0 + message := once "" + message.copy(pointer_message_header) + print_data_in(message, x, y, presure, pointer.motion_axis_data(4), + pointer.motion_axis_data(5), + pointer.motion_axis_data(6), pointer.event_time, + once "unchanged") + xinput_ivy.ivy.send_message(message) + end + old_presure := presure + end + + + print_data_in(message: STRING; x, y, presure, v4, v5, v6, time: INTEGER; proximity_description: STRING) is + do + message.append(once " x=") + device_to_screen_x(x).append_in(message) + message.append(once " y=") + device_to_screen_y(y).append_in(message) + message.append(once " presure=") + presure.append_in(message) + message.append(once " tilt_x=") + v4.low_16.append_in(message) + message.append(once " tilt_y=") + v5.low_16.append_in(message) + message.append(once " wheel=") + v6.low_16.append_in(message) + message.append(once " predicted_x=") + device_to_screen_x(predicted_x).append_in(message) + message.append(once " predicted_y=") + device_to_screen_y(predicted_y).append_in(message) + message.append(once " type=") + message.append(type_to_name(v4.high_16)) + message.append(once " serial_number=") + (v5.high_16.to_integer_32 |<< 16).bit_or(v6.high_16).append_in(message) + message.append(once " time=") + time.append_in(message) + message.append(once " hires_x=") + (x/86400).append_in(message) -- **** geometrie paramétrable + message.append(once " hires_y=") + (y/65000).append_in(message) -- **** geometrie paramétrable + message.append(once " proximity=") + message.append(proximity_description) + end + + button(pressed: BOOLEAN; pointer: X_INPUT_DEVICE) is + local + x, y, presure: INTEGER + t3: REAL_64 + message: STRING + do + x := pointer.motion_axis_data(1) + y := pointer.motion_axis_data(2) + --update_predicted_position(x, y, pointer.event_time) + x_history.remove_first + x_history.add_last(x) + y_history.remove_first + y_history.add_last(y) + time_history.remove_first + time_history.add_last(pointer.event_time) + t3 := mean(time_history) + if t3 /= t2 then + update_predicted_position(mean(x_history), mean(y_history), t3) + end + message := once "" + message.copy(button_message_header) + message.append(once " button=") + pointer.button_number.append_in(message) + message.append(once " status=") + if pressed then + message.append(once "down") + else + message.append(once "up") + end + presure := pointer.motion_axis_data(3) + print_data_in(message, x, y, presure, pointer.motion_axis_data(4), + pointer.motion_axis_data(5), + pointer.motion_axis_data(6), pointer.event_time, + once "unchanged") + xinput_ivy.ivy.send_message(message) + end + + proximity(in: BOOLEAN; pointer: X_INPUT_DEVICE) is + local + x, y: INTEGER + t3: REAL_64 + message, proximity_status: STRING + do + x := pointer.proximity_axis_data(1) + y := pointer.proximity_axis_data(2) + --update_predicted_position(x, y, pointer.event_time) + --*** exploiter le cas proximity in=True pour vider l'historique + x_history.remove_first + x_history.add_last(x) + y_history.remove_first + y_history.add_last(y) + time_history.remove_first + time_history.add_last(pointer.event_time) + t3 := mean(time_history) + if t3 /= t2 then + update_predicted_position(mean(x_history), mean(y_history), t3) + end + if in then + proximity_status := once "In" + else + proximity_status := once "Out" + end + message := once "" + message.copy(pointer_message_header) + print_data_in(message, x, y, pointer.proximity_axis_data(3), + pointer.proximity_axis_data(4), + pointer.proximity_axis_data(5), + pointer.proximity_axis_data(6), + pointer.event_time, proximity_status) + xinput_ivy.ivy.send_message(message) + end + + predicted_x, predicted_y: INTEGER + + int_update_predicted_position(x3, y3, t3: INTEGER) is + local + dt: REAL -- delta time, temporary value + s3x, s3y, s3: REAL -- speed beetween P2 and P3 + s3xn, s3yn: REAL -- normalized speed between point P2 and P3 + a3x, a3y: REAL -- acceleration at point P2 (needs P3!) + a3xm, a3ym: REAL -- a3 value in mobile coordinates (s2 vector) + a4x, a4y: REAL -- a3 value rotated by (s2 vector, s3 vector) angle + do + dt := t3 - t2 + --s3x := (x3 - x2).to_real_64 / dt + --s3y := (y3 - y2).to_real_64 / dt + s3 := (s3x * s3x + s3y * s3y).sqrt + s3xn := s3x / s3 + s3yn := s3y / s3 + + dt := (t3 - t1) / 2 + a3x := (s3x - s2x) / dt + a3y := (s3y - s2y) / dt + a3xm := a3x * s2xn + a3y * s2yn + a3ym := -a3x * s2yn + a3y * s2xn + a4x := s3xn * a3xm - s3yn * a3ym + a4y := s3yn * a3xm + s3xn * a3ym + + dt := (t3 - t2 + prediction_time) / 2 + predicted_x := x3 + (prediction_time * (s3x + a4x * dt)).force_to_integer_32 + predicted_y := y3 + (prediction_time * (s3y + a4y * dt)).force_to_integer_32 + + if (prediction_time * (s3y + a4y * dt)).abs > 5300 then + io.put_string(once "x2=" + x2.to_string + once " y2=" + y2.to_string) + io.put_string(once " x3=" + x3.to_string + once " y3=" + y3.to_string) + io.put_string(once " s3x=" + s3x.to_string + once " s3y=" + s3y.to_string) + io.put_string(once " a3x=" + a3x.to_string + once " a3y=" + a3y.to_string) + io.put_string(once " a3xm=" + a3xm.to_string + once " a3ym=" + a3ym.to_string) + io.put_string(once " a4x=" + a4x.to_string + once " a4y=" + a4y.to_string) + io.put_string(once " dt=" + dt.to_string) + io.put_string(once " ****") + io.put_new_line + end + -- Shift values + x2 := x3; y2 := y3 + s2x := s3x; s2y := s3y + s2xn := s3xn; s2yn := s3yn + t1 := t2; t2 := t3 + end + + update_predicted_position(x3, y3, t3: REAL) is + require + t2 /= t3 + local + dt: REAL -- delta time, temporary value + s3x, s3y, s3: REAL -- speed beetween P2 and P3 + s3xn, s3yn: REAL -- normalized speed between point P2 and P3 + a3x, a3y: REAL -- acceleration at point P2 (needs P3!) + a3xm, a3ym: REAL -- a3 value in mobile coordinates (s2 vector) + a4x, a4y: REAL -- a3 value rotated by (s2 vector, s3 vector) angle + do + dt := t3 - t2 + s3x := (x3 - x2) / dt + s3y := (y3 - y2) / dt + s3 := (s3x * s3x + s3y * s3y).sqrt + if s3 /= 0 then + s3xn := s3x / s3 + s3yn := s3y / s3 + end + + dt := (t3 - t1) / 2 + a3x := (s3x - s2x) / dt + a3y := (s3y - s2y) / dt + a3xm := a3x * s2xn + a3y * s2yn + a3ym := -a3x * s2yn + a3y * s2xn + a4x := s3xn * a3xm - s3yn * a3ym + a4y := s3yn * a3xm + s3xn * a3ym + + --dt := (t3 - t2 + prediction_time) / 2 + -- acceleration is constant + -- predicted_x := (x3 + prediction_time * (s3x + a3x * dt)).force_to_integer_32 + -- predicted_y := (y3 + prediction_time * (s3y + a3y * dt)).force_to_integer_32 + + -- acceleration is constant in mobile coordinates + -- predicted_x := (x3 + prediction_time * (s3x + a4x * dt)).force_to_integer_32 + -- predicted_y := (y3 + prediction_time * (s3y + a4y * dt)).force_to_integer_32 + + -- acceleration variation is constant + -- a4x := a3x + (a3x - a2x) * (prediction_time + t2 - t1) / (t3 + t1 - t2 - t0) + -- a4y := a3y + (a3y - a2y) * (prediction_time + t2 - t1) / (t3 + t1 - t2 - t0) + -- predicted_x := (x3 + prediction_time * (s3x + a4x * dt)).force_to_integer_32 + -- predicted_y := (y3 + prediction_time * (s3y + a4y * dt)).force_to_integer_32 + + -- half constant in mobile coordinates, half constant variation + dt := (prediction_time + t2 - t1) / (t3 + t1 - t2 - t0) + a4x := (a4x + a3x + (a3x - a2x) * dt) / 2 + a4y := (a4y + a3y + (a3y - a2y) * dt) / 2 + + dt := (t3 - t2 + prediction_time) / 2 + predicted_x := (x3 + prediction_time * (s3x + a4x * dt)).force_to_integer_32 + predicted_y := (y3 + prediction_time * (s3y + a4y * dt)).force_to_integer_32 + + -- Shift values + x2 := x3; y2 := y3 + s2x := s3x; s2y := s3y + s2xn := s3xn; s2yn := s3yn + a2x := a3x; a2y := a3y + t0 := t1; t1 := t2; t2 := t3 + end + + a2x, a2y: REAL + + t0: REAL + + --x2, y2: INTEGER -- point P2 coordinates + x2, y2: REAL -- point P2 coordinates + + s2x, s2y: REAL -- speed beetween P1 and P2 + + s2xn, s2yn: REAL -- normalized speed between P1 and P2 + + --t1, t2: INTEGER -- timestamp for points P1 and P2 + t1, t2: REAL -- timestamp for points P1 and P2 + +end diff --git a/xinput_ivy.c b/xinput_ivy.c new file mode 100644 index 0000000..3804a6d --- /dev/null +++ b/xinput_ivy.c @@ -0,0 +1,20921 @@ +#ifdef __cplusplus +extern "C" { +#endif +/* +ANSI C code generated by SmartEiffel The GNU Eiffel Compiler, Eiffel tools and libraries +Release 2.4 (??? September ??th 2007) [????] +Copyright (C), 1994-2002 - INRIA - LORIA - ESIAL UHP Nancy 1 - FRANCE +Copyright (C), 2003-2005 - INRIA - LORIA - IUT Charlemagne Nancy 2 - FRANCE +D.COLNET, P.RIBET, C.ADRIAN, V.CROIZIER F.MERIZEN - SmartEiffel@loria.fr +http://SmartEiffel.loria.fr +C Compiler options used: -pipe -O3 -fomit-frame-pointer +*/ + +#ifdef __cplusplus +} +#endif +#include "xinput_ivy.h" +#ifdef __cplusplus +extern "C" { +#endif +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +/* + This file (SmartEiffel/sys/runtime/base.c) is included for _all_ modes of + compilation (-boost, -no_check, ... -all_check). +*/ + +/* + Byte swapping function +*/ +void copy_swap_16(const uint16_t *src, uint16_t *dest, int count){ + while (count--) { + *dest++ = (*src << 8) | (*src >> 8); + src++; + } +} + + +/* + The wrapper for `malloc' (generated C code is supposed to use + only `se_malloc' instead of direct `malloc'). +*/ +void* se_malloc(size_t size) { + void *result = malloc(size); + if (result == NULL) { + handle(SE_HANDLE_NO_MORE_MEMORY, NULL); +#ifdef SE_EXCEPTIONS + internal_exception_handler(No_more_memory); +#elif !defined(SE_BOOST) + error0("No more memory.", NULL); +#else + fprintf(SE_ERR,"No more memory (malloc failed).\n"); + exit(EXIT_FAILURE); +#endif + } + return result; +} + +/* + The wrapper for `calloc' (generated C code is supposed to use + only `se_calloc' instead of direct `calloc'). +*/ +void* se_calloc(size_t nmemb, size_t size) { + void *result = calloc(nmemb,size); + if (result == NULL) { + handle(SE_HANDLE_NO_MORE_MEMORY, NULL); +#ifdef SE_EXCEPTIONS + internal_exception_handler(No_more_memory); +#elif !defined(SE_BOOST) + error0("No more memory.", NULL); +#else + fprintf(SE_ERR,"No more memory (calloc failed).\n"); + exit(EXIT_FAILURE); +#endif + } + return result; +} + +/* + The wrapper for `realloc' (generated C code is supposed to use + only `se_realloc' instead of direct `realloc'). +*/ +void* se_realloc(void* src, size_t size) { + void *result = realloc(src, size); + if (result == NULL) { + handle(SE_HANDLE_NO_MORE_MEMORY, NULL); +#ifdef SE_EXCEPTIONS + internal_exception_handler(No_more_memory); +#elif !defined(SE_BOOST) + error0("No more memory.", NULL); +#else + fprintf(SE_ERR,"No more memory (realloc failed).\n"); + exit(EXIT_FAILURE); +#endif + } + return result; +} + +/* ---------------------------------------------------------------------- */ + +void se_die (int code) { + handle(SE_HANDLE_DIE_WITH_CODE, &code); + exit(code); +} + +/* + Runtime hooks + */ + +static se_runtime_handler_t** handlers = NULL; +int handlers_count; + +void register_handler(se_runtime_handler_t*handler) { + int new_count = handlers_count + 1; + handlers = (se_runtime_handler_t**)se_realloc(handlers, (new_count) * sizeof(void*)); + handlers[handlers_count] = handler; + handlers_count = new_count; +} + +void _handle(se_handler_action_t action, void*data) { + int i; + for (i = 0; i < handlers_count; i++) { + handlers[i](action, data); + } +} + +int se_cmpT189(T189 o1,T189 o2){ +return memcmp(&o1,&o2,sizeof(o1));}/*--*/ + +int se_cmpT176(T176 o1,T176 o2){ +return memcmp(&o1,&o2,sizeof(o1));}/*--*/ +T110 M110={110,(void*)0}; +T120 M120={120,(void*)0}; +T189 M189={0}; +T176 M176={{0},0}; +T286 M286={286,(void*)0}; +T277 M277={277,(void*)0}; +T271 M271={271,(void*)0}; +T268 M268={268,(void*)0}; +T266 M266={(void*)0,(void*)0,(void*)0}; +T265 M265={265,(void*)0}; +T264 M264={(void*)0,0,(void*)0}; +T258 M258={258,(void*)0}; +T256 M256={(void*)0,(void*)0,(void*)0}; +T254 M254={(void*)0,0,0}; +T253 M253={253,(void*)0}; +T252 M252={0,0,(void*)0}; +T249 M249={249,(void*)0}; +T246 M246={(void*)0,(void*)0,(void*)0}; +T245 M245={245,(void*)0}; +T244 M244={(void*)0,0,0,0,(void*)0}; +T243 M243={243,(void*)0}; +T147 M147={0,0,{{0},0},0,0,(void*)0,0,(void*)0,0,(void*)0,0,0}; +T236 M236={(void*)0,0,0}; +T235 M235={(void*)0,0,0}; +T234 M234={(void*)0,0,0,0,(void*)0}; +T232 M232={(void*)0,0,0}; +T230 M230={(void*)0,0,0,0,(void*)0}; +T228 M228={(void*)0,0,0,0,(void*)0}; +T227 M227={(void*)0,0,0,0,(void*)0}; +T226 M226={(void*)0,0,0,0,(void*)0}; +T225 M225={(void*)0,0,0}; +T158 M158={(void*)0}; +T54 M54={(void*)0,(void*)0,0}; +T139 M139={0,0,0}; +T223 M223={(void*)0,0,0}; +T142 M142={0}; +T222 M222={(void*)0,0,0}; +T141 M141={0,0,(void*)0,(void*)0,(void*)0}; +T221 M221={(void*)0,0,0}; +T218 M218={(void*)0,0,0,0,(void*)0}; +T217 M217={(void*)0,0,0}; +T216 M216={(void*)0,0,0}; +T215 M215={(void*)0,0,0,0,(void*)0}; +T214 M214={(void*)0,0,0}; +T213 M213={(void*)0,0,0,0,0}; +T211 M211={(void*)0,0,0,0,(void*)0}; +T208 M208={(void*)0,0,0,0,(void*)0}; +T146 M146={146,(void*)0,(void*)0,0,0,(void*)0,(void*)0,(void*)0}; +T207 M207={(void*)0,0,0}; +T206 M206={(void*)0,0,0}; +T148 M148={(void*)0,(void*)0,(void*)0,(void*)0,0,0}; +T131 M131={131,(void*)0,0}; +T130 M130={(void*)0,0,(void*)0,(void*)0}; +T128 M128={128,0,0,0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,0,(void*)0}; +T72 M72={(void*)0,0,0,(void*)0,0,0,0,0,0,0,(void*)0}; +T53 M53={(void*)0,0,(void*)0,0}; +T46 M46=(void*)0; +T175 M175={(void*)0}; +T205 M205={(void*)0,0,0}; +T143 M143=0; +T204 M204={(void*)0,0,0}; +T67 M67={0,(void*)0,(void*)0,0,0,0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; +T43 M43={(void*)0}; +T69 M69={(void*)0,0,0,0,0,0,(void*)0,(void*)0,0,(void*)0,(void*)0,(void*)0,0,0,0,0,0,0,0,0,0,0,0,0,0}; +T7 M7={(void*)0,0,0}; +T70 M70={70,0,0,(void*)0,(void*)0,0,(void*)0,0,(void*)0,(void*)0,(void*)0,(void*)0}; +T64 M64={0,0,(void*)0,(void*)0,(void*)0,(void*)0}; +T25 M25={(void*)0,(void*)0,(void*)0,(void*)0,0,0,0,(void*)0}; +/*Aliased storage area or unicode storage.*/ +char*s25_0=""; +char*s25_21190322=" Status: "; +char*s25_314746909=" status=up time="; +char*s69_190991=" type="; +char*s69_475="In"; +char*s13_1432888418="Some feature is not yet implemented (i.e. feature `not_yet_implemented\' of\nclass ANY has been called somewhere). Just run this code under the debugger\nto know the `not_yet_implemented\' caller. If this is a feature of the\nSmartEiffel library, you may consider to post your implementation on the\nSmartEiffel mailing list.\n e-mail: SmartEiffel@loria.fr\n Happy debug and thanks in advance.\n http://SmartEiffel.loria.fr\n The SmartEiffel team.\n\nThe error occured in the type "; +char*s69_697="up"; +char*s69_1961093439="marker_pen_2181"; +char*s69_104371129="airbrush_2323"; +char*s25_44143=":3110"; +char*s69_104371267="airbrush_3346"; +char*s69_1699147265="classic_pen_eraser_2075"; +char*s13_1210=".\n\n"; +char*s69_1756148648=" predicted_x="; +char*s69_1756148653=" predicted_y="; +char*s25_1948078333="slider_event device_id="; +char*s69_1461=" x="; +char*s69_1466=" y="; +char*s69_23436791=" presure="; +char*s25_1666922512="pad_event device_id="; +char*s69_56246305="unchanged"; +char*s25_1957581="default"; +char*s25_1403610646=" side=left time="; +char*s69_4725661=" tilt_x="; +char*s69_4725666=" tilt_y="; +char*s69_4738061=" status="; +char*s25_1213754110="XInputExtension is not available."; +char*s25_765567725="_event device_id="; +char*s69_2179769="pointer"; +char*s25_751291742="\" is not a valid y_offset (an integer is needed).\n"; +char*s25_1554692325="Missing bus identifier after -b option.\n"; +char*s25_357338863="\" is not a valid time (a real number is needed).\n"; +char*s69_2676="Out"; +char*s69_1874520032="stroke_pen_2098"; +char*s69_1619665677="classic_pen_2067"; +char*s25_1491411490="\" is not a valid x_offset (an integer is needed).\n"; +char*s25_4487261=" button="; +char*s69_1940108584="grip_pen_2083"; +char*s25_694149733=" status=down time="; +char*s64_1686724329="Vision is currently written for X and Windows.\n"; +char*s69_586741066=" proximity="; +char*s25_703548632="This tool get data from wacom pen screen and is\n able to send them to applications using ivy bus.\n\nOptions:\n -help: print this help.\n\n -list_devices: all available devices are listed.\n\n -pad=name: report pad data from the pad device with this name.\n\n -wacom_pointer=name: report pointer data from the pointer device with\n this name. Ex: stylus.\n\n -bus=[address]:port: specify the ivy bus (default is :3110).\n\n -b [address]:port: specify the ivy bus (default is :3110) (added for\n compatibility with other ivy tools).\n\n -application=name: specify the application name on the ivy bus\n (default is wacom).\n\n -identifier=id: this identifier will be used in ivy messages\n device_id value (default is \"default\").\n\n -x_offset=n: specify the x-offset for the wacom device\n for the display configuration (default is 0).\n\n -y_offset=n: " +" specify the y-offset for the wacom device\n for the display configuration (default is 0).\n\n -prediction=t: change the prediction time for the physical position.\n (default is 25ms).\n\n -ignore=n: number of messages to ignore before sending a new\n position message (this reduces message frequency).\n (default is 0 => \176""120message/s).\n\011""\nOptions are considered in the order they appear in the command line. A new\nvalue overrides the previous one. \"wacom_pointer\" and \"pad\" are created where they\nappear, with known information.\n\nMessages:\n slider_event device_id=radar_wacom value=4 side=left time=4523271\n device_id: identifier (see options).\n value: new slider value (0 when the\n\011""\011""\011""\011""\011""\011""\011""\011""\011""\011""finger leaves the slider).\n side: left or right.\n time: event time (ms), X server reference.\n\n pad_event device_id=radar_wacom butt" +"on=12 status=left time=4523271\n device_id: identifier (see options).\n button: button identifier.\n status: up or down.\n time: event time (ms), X server reference.\n\n button_event device_id=radar_wacom button=2 status=up x=1290 y=325\n presure=307 tilt_x=-20 tilt_y=15 wheel=0 predicted_x=1272 predicted_y=322\n type=123 serial_number=429389 time=4523271 hires_x=0.827 hires_y=0.231\n proximity=unchanged\n pointer_event device_id=radar_wacom x=1290 y=325\n presure=307 tilt_x=-20 tilt_y=15 wheel=0 predicted_x=1272 predicted_y=322\n type=123 serial_number=429389 time=4523271 hires_x=0.827 hires_y=0.231\n proximity=unchanged\n device_id: identifier (see options).\n button: button identifier.\n status: up or down.\n x: pointer position (display coordinates).\n y: pointer position (display coordi" +"nates).\n presure: presure value ([0, 1023] for intuos 3).\n tilt_x: device tilt in degrees.\n tilt_y: device tilt in degrees.\n wheel: rotation value (device type dependent value).\n predicted_x: predicted position. It is expected to be\n the current position of the real device.\n predicted_y: predicted position. It is expected to be\n the current position of the real device.\n type: the type of the device (pen, eraser, mouse,\n cursor, airbrush...).\n serial_number: the serial number of the device.\n time: event time (ms), X server reference.\n hires_x: pointer position (device coordinates, in range [0,1]).\n hires_y: pointer position (device coordinates, in range [0,1]).\n " +" proximity: unchanged, in, out\n"; +char*s25_89639="wacom"; +char*s69_15980="down"; +char*s69_397440="button"; +char*s25_69208946="\" is not a valid pad name.\n"; +char*s69_188916=" time="; +char*s25_447643634="\" is not a valid pointer name.\n"; +char*s69_2057747851="grip_pen_eraser_2091"; +char*s25_3479972=" (Type: "; +char*s25_557679246=" available)"; +char*s25_1638797568=" side=right time="; +char*s25_1260406502="Unknown option "; +char*s69_22702411=" hires_x="; +char*s69_22702416=" hires_y="; +char*s25_946366=" value="; +char*s69_1501987274="airbrush_eraser_2331"; +char*s25_382517595="\" is not a valid ignore rate (an integer is needed).\n"; +char*s69_952626=" wheel="; +char*s69_2112369621=" serial_number="; +char*s69_10739017="pen_2049"; +char*s69_10739024="pen_2066"; +char*s69_10739030="pen_2082"; +char*s70_202554="-READY"; +char*s143_1472358418="XInputExtension"; +char*s25_1959886733=" unavailable)"; +char*s69_1257860908="eraser_2090"; +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +void se_print_run_time_stack (void) { + handle(SE_HANDLE_ENTER_PRINT_STACK, NULL); + fprintf(SE_ERR,"Eiffel program crash at run time.\n"); + fprintf(SE_ERR,"No trace when using option \"-boost\"\n"); + handle(SE_HANDLE_EXIT_PRINT_STACK, NULL); +} + +void se_signal_handler(int sig) { + handle(SE_HANDLE_RUNTIME_ERROR, NULL); + printf("Received signal %d.\n",sig); + se_print_run_time_stack(); + exit(EXIT_FAILURE); +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ + +/* + This file (SmartEiffel/sys/runtime/gc_lib.c) is automatically included + when the Garbage Collector is used (default, unless option -no_gc has been + selected). +*/ +/* + The `mark_stack_and_registers' C function is called by the Garbage + Collector (GC) of SmartEiffel. It has to be customized for some systems, + but also for some C compilers. This file provides some definitions in the + end and has to be completed for systems which need specific work. + + On some architectures, addresses increase as the stack grows; or, + conversely, addresses decrease as the stack grows. A C compiler may be + clever enough to hide some root object inside registers. Unfortunately all + registers are not always accessible via the C `setjmp' function! + + Thus, in order to be able to use the GC on your architecture/C-compiler, + you have to provide the correct `mark_stack_and_registers' function. + + What is the `mark_stack_and_registers' function supposed to do? The + `mark_stack_and_registers' function is supposed to notify the GC with all + the possible roots one can find in the C stack and registers by calling the + `gc_mark' function. A root is an object which must not be collected. The + SmartEiffel GC already knows about some root objects like once function + results or manifest strings. The `mark_stack_and_registers' function has to + notify the other possible roots. Obviously, one can find in the C stack any + kind of adresses, but the `gc_mark' function is clever enough to determine + if the passed pointer is an Eiffel object or not. When the passed pointer + reaches some Eiffel object, this object as well as its descendant(s) are + automatically marked as un-collectable. + + In order to provide the most appropriate `mark_stack_and_registers' + function, the very first question is to know about the way the C stack is + managed (addresses of the stack may increase or decrease as the C stack + grows). The DEFAULT BEHAVIOUR FOR UNKNOWN SYSTEMS is to consider ADDRESSES + DECREASE AS THE STACK GROWS, as it's the most common case. The global C + variable `stack_bottom' is set with some pointer which is supposed to be + the bottom of the stack (this variable is automatically initialized in the + C main function). Note: using the current stack pointer inside + `mark_stack_and_registers', it is quite obvious to determine if addresses + increase or not as the C stack grows. Note2: on some systems, the stack is + not in contiguous addresses. In such case, `mark_stack_and_registers' has + to go through all the stack fragments. + + Some roots may be stored only in registers and not in the C stack. In + order to reach the registers as well, the first attempt is to use setjmp, + in the hope that setjmp will save registers in the stack! Note: this + technique do not work on processors using windows registers (such as sparc + processors). + +*/ + +int se_gc_strategy = SE_GC_DEFAULT_MEMORY_STRATEGY; + +int collector_counter = 0; + +static void gcna_align_mark(rsoc*c,void*o); +static rsoc*rsocfl=NULL; /* ReSizable Object Chunk Free List. */ + +void**stack_bottom=NULL; +mch**gcmt=NULL; /* Garbage Collector Main Table. */ +int gcmt_max=2048; +int gcmt_used=0; +fsoc*fsocfl=NULL; /* Fixed Size Object Chunk Free List. */ +int gc_is_off=1; +unsigned int fsoc_count=0; +unsigned int rsoc_count=0; +void*gcmt_tail_addr=NULL; + +static int chunk_rounded(int size) { + int rounded_size = size; + int diff = rounded_size%RSOC_SIZE; + + if (diff != 0) rounded_size += (RSOC_SIZE-diff); + return rounded_size; +} + +/* Return the index where chunk `c' is (or is to be) in the `gcmt', + between `min' and `max' indexes. */ +static unsigned int binary_search_in_gcmt(register unsigned int min, + register unsigned int max, + register mch* c){ + register unsigned int mid; + while (min>1; + if (gcmt[mid] 50) && (count > (rsoc_count >> 1))) { + current=rsocfl; + rsocfl=NULL; + while (NULL != current) { + next=current->next; + if (current->isize == current->header.size) { + where = binary_search_in_gcmt(0, where-1, (mch*)current); + how_many = gcmt_used - 1 - where; + if (how_many > 0) + memmove(gcmt+where, gcmt+where+1, how_many*sizeof(mch*)); + free(current); gcmt_used--; rsoc_count--; + } + else { + current->next=rsocfl; + rsocfl=current; + } + current = next; + } + } +} + +int gc_memory_used(void) { + int i; + int result = 0; + mch* mch; + for (i = gcmt_used; i --> 0; ) { + mch = gcmt[i]; + switch(mch->state_type) { + case RSO_USED_CHUNK: + case FSO_USED_CHUNK: + case FSO_STORE_CHUNK: + result += mch->size; + break; + default: + break; + } + } + return result; +} + +void gc_sweep(void) { + mch** p2 = gcmt; + mch** p1 = gcmt+1; + mch**eogcmt=gcmt+gcmt_used; + if (FREE_CHUNK((*p2)->state_type)) { + if (RSO_FREE_CHUNK == ((*p2)->state_type)) { + ((rsoc*)(*p2))->next=NULL; + rsocfl=((rsoc*)(*p2)); + } + else { + rsocfl=NULL; + } + } + else { + ((*gcmt)->swfp)(*p2); + if (RSO_FREE_CHUNK==((*p2)->state_type)) { + ((rsoc*)(*p2))->next=NULL; + rsocfl=((rsoc*)(*p2)); + } + else { + rsocfl=NULL; + } + } + while (p1 < eogcmt) { + if (FREE_CHUNK((*p1)->state_type)) { + if (RSO_FREE_CHUNK == ((*p1)->state_type)) { + if (RSO_FREE_CHUNK == ((*p2)->state_type)) { + if ( (((rsoc*)*p1)->isize==0) && ((char*)(*p2))+(*p2)->size == ((char*)(*p1))) { + ((*p2)->size)+=((*p1)->size); + p1++; + } + else { + ((rsoc*)(*p1))->next=rsocfl; + rsocfl=((rsoc*)(*p1)); + *(p2+1)=*p1; p2++; p1++; + } + } + else { + ((rsoc*)(*p1))->next=rsocfl; + rsocfl=((rsoc*)(*p1)); + *(p2+1)=*p1; p2++; p1++; + } + } + else { + *(p2+1)=*p1; p2++; p1++; + } + } + else { + ((*p1)->swfp)(*p1); + if (RSO_FREE_CHUNK == ((*p1)->state_type)) { + if (RSO_FREE_CHUNK == ((*p2)->state_type)) { + if ( (((rsoc*)*p1)->isize==0) && ((char*)(*p2))+(*p2)->size == ((char*)(*p1))) { + ((*p2)->size)+=((*p1)->size); + p1++; + } + else { + ((rsoc*)(*p1))->next=rsocfl; + rsocfl=((rsoc*)(*p1)); + *(p2+1)=*p1; p2++; p1++; + } + } + else { + ((rsoc*)(*p1))->next=rsocfl; + rsocfl=((rsoc*)(*p1)); + *(p2+1)=*p1; p2++; p1++; + } + } + else { + *(p2+1)=*p1; p2++; p1++; + } + } + } + gcmt_used=(p2-gcmt)+1; + may_free_rsocfl(); +} + +/* return the mch containing p or NULL if p is not + * a valid address or was externally allocated + */ +mch * gc_find_chunk(void * p){ + if ((p>((void*)*gcmt))&&(p<=gcmt_tail_addr)) { + int i1=0; + int i2=gcmt_used-1; + int m=i2>>1; + mch*c; + for (;i2>i1;m=((i1+i2)>>1)) { + if (p<=((void*)gcmt[m+1])) { + i2=m; + } + else { + i1=m+1; + } + } + c=gcmt[i2]; + if((char*)p<(char*)c+c->size) /* check for upper bound */ + if (!(FREE_CHUNK(c->state_type))) + return c; + } + return NULL; +} + +void gc_mark(void*p) { + mch * c = gc_find_chunk(p); + if(NULL != c) + (c->amfp)(c,p); +} + +int gc_stack_size(void) { + void*stack_top[2]={NULL,NULL}; + if (stack_top > stack_bottom) { + return ((void**)stack_top)-((void**)stack_bottom); + } + else { + return ((void**)stack_bottom)-((void**)stack_top); + } +} + +/* + To delay Garbage Collection when the stack is too large. + To allow fast increase of ceils. +*/ +#define FSOC_LIMIT (10240/((FSOC_SIZE)>>10)) +#define RSOC_LIMIT (10240/((RSOC_SIZE)>>10)) + +/* + When stack is too large, collection may be delayed. +*/ +#define GCLARGESTACK 50000 + +int garbage_delayed(void) { + /* + To delay the first GC call. + */ + if (gc_stack_size() > GCLARGESTACK) { + if (fsoc_count_ceil <= fsoc_count) { + if (rsoc_count_ceil <= rsoc_count) { + if ((fsoc_count */ + + /* --perf-- if (fsocfl == NULL) { */ + if (fsoc_count >= fsoc_count_ceil) { + if (fsoc_count_ceil < FSOC_LIMIT) { + fsoc_count_ceil <<= 1; + } + else { + unsigned int c = fsoc_count + (fsoc_count/3); + if (fsoc_count_ceil < c) + fsoc_count_ceil = c; + } + } + /* --perf-- } + else { + if (fsoc_count_ceil < fsoc_count) { + fsoc_count_ceil = fsoc_count; + } + } + */ + /* Compute rsoc_count_ceil: */ + /* --perf-- if (rsocfl == NULL) {*/ + if (rsoc_count >= rsoc_count_ceil) { + if (rsoc_count_ceil < RSOC_LIMIT) { + rsoc_count_ceil <<= 1; + } + else { + unsigned int c = rsoc_count + (rsoc_count / 3); + if (rsoc_count_ceil < c) { + rsoc_count_ceil = c; + } + } + } + /* --perf -- } + else { + if (rsoc_count_ceil < rsoc_count) { + rsoc_count_ceil = rsoc_count; + } + } + */ +} + +static void gc_add_into_gcmt(mch*c) { + /* Update the `gcmt' (Garbage Collector Main Table) by adding the + new `mch' (Memory Chunk Header).`gcmt_used' is updated. + */ + unsigned int where=0; + unsigned how_many; + if (gcmt_used>0){ + where=binary_search_in_gcmt(0, gcmt_used-1, c); + if (gcmt_used == gcmt_max) { + gcmt_max <<= 1; + gcmt = ((mch**)(se_realloc(gcmt,(gcmt_max+1)*sizeof(void*)))); + } + how_many = gcmt_used - where; + if (how_many > 0) + memmove(gcmt+where+1, gcmt+where, how_many*sizeof(mch*)); + } + gcmt[where]=c; + gcmt_used++; +} + +static char*rso_from_store(na_env*nae,unsigned int size) { + rsoh*r=(nae->store); + nae->store_left-=size; + if ((nae->store_left) > sizeof(rsoh)) { + r->header.size=size; + nae->store=((rsoh*)(((char*)(nae->store))+size)); + } + else { + r->header.size=size+nae->store_left; + nae->store_left=0; + } + (r->header.magic_flag)=RSOH_UNMARKED; + ((void)memset((r+1),0,r->header.size-sizeof(rsoh))); + return (char*)(r+1); +} + +static void rsoc_sweep(rsoc*c) { + na_env*nae=c->nae; + rsoh*gp=(rsoh*)&(c->first_header); + rsoh*pp; + rsoh*eoc=((rsoh*)(((char*)c)+c->header.size)); + c->free_list_of_large=NULL; + if (c->header.size > RSOC_SIZE) { + if (gp->header.magic_flag == RSOH_MARKED) { + gp->header.magic_flag=RSOH_UNMARKED; + /* No need to register chunks with no free_list_of_large + c->next=nae->chunk_list; + nae->chunk_list=c; + */ + } + else { + c->header.state_type=RSO_FREE_CHUNK; + } + return; + } + while (gpheader.magic_flag == RSOH_MARKED) { + gp->header.magic_flag=RSOH_UNMARKED; + gp=((rsoh*)(((char*)gp)+gp->header.size)); + if(gp>=eoc) { + /* No need to register chunks with no free_list_of_large + c->next=nae->chunk_list; + nae->chunk_list=c; + */ + return; + } + } + gp->header.magic_flag=RSOH_FREE; + pp=(rsoh*)(((char*)gp)+gp->header.size); + while ((ppheader.magic_flag != RSOH_MARKED)) { + gp->header.size+=pp->header.size; + pp=((rsoh*)(((char*)pp)+pp->header.size)); + } + if (gp->header.size >= RSOC_MIN_STORE) { + if (nae->store_left==0) { + nae->store_left=gp->header.size; + nae->store=gp; + nae->store_chunk=c; + } + else if (nae->store->header.size < gp->header.size) { + ((fll_rsoh*)nae->store)->nextflol=nae->store_chunk->free_list_of_large; + nae->store_chunk->free_list_of_large=((fll_rsoh*)nae->store); + nae->store_left=gp->header.size; + nae->store=gp; + nae->store_chunk=c; + } + else { + ((fll_rsoh*)gp)->nextflol=c->free_list_of_large; + c->free_list_of_large=((fll_rsoh*)gp); + } + } + gp=pp; + } + if (((rsoh*)(&c->first_header))->header.size >= + (c->header.size-sizeof(rsoc)+sizeof(rsoh))){ + c->header.state_type=RSO_FREE_CHUNK; + nae->store_chunk=NULL; + nae->store_left=0; + } + else{ + c->next=nae->chunk_list; + nae->chunk_list=c; + } +} + +/* *** To be removed */ +#ifdef __TINYC__ +static rsoc MRSOC = { +#else +static const rsoc MRSOC = { +#endif + { + RSOC_SIZE, + RSO_USED_CHUNK, + ((void(*)(mch*,void*))gcna_align_mark), + ((void(*)(mch*))rsoc_sweep) + }, + 0, + NULL, + NULL, + NULL, + { + { + 0, + RSOH_MARKED + } + } +}; + +static void rsoc_malloc(na_env*nae) { + rsoc* r = ((rsoc*)(se_malloc(RSOC_SIZE))); + rsoc_count++; + *r=MRSOC; + r->nae=nae; + r->isize=RSOC_SIZE; + nae->store=(&(r->first_header)); + nae->store_left=RSOC_SIZE-sizeof(rsoc)+sizeof(rsoh); + nae->store_chunk=r; + r->next=nae->chunk_list; + nae->chunk_list=r; + gc_add_into_gcmt((mch*)r); +} + +static rsoc* rsocfl_best_fit(unsigned int size) { + register unsigned int best_size = 0; + unsigned int acceptable_loss; + register rsoc *pc, *best_pc, *best_c, *c; + if (NULL==rsocfl) + return NULL; + pc=NULL; + best_pc=NULL; + best_c=NULL; + c=rsocfl; + if (SE_GC_DEFAULT_MEMORY_STRATEGY == se_gc_strategy) + acceptable_loss = (size >> 4); + else if (SE_GC_LOW_MEMORY_STRATEGY == se_gc_strategy) + acceptable_loss = 0; + else /* SE_GC_HIGH_MEMORY_STRATEGY == se_gc_strategy */ + acceptable_loss = (size >> 2); + + while ((NULL!=c)&&(NULL==best_c)){ + if (c->header.size>=size){ + best_c=c; + best_pc=pc; + best_size=c->header.size; + } + pc=c; + c=c->next; + } + if (NULL==c){ + if (NULL != best_pc) + best_pc->next=best_c->next; + else if (best_c==rsocfl) + rsocfl=best_c->next; + return best_c; + } + if ((best_size - size) > acceptable_loss){ + do { + if ((c->header.size >= size) && (c->header.size < best_size)) { + best_c = c; + best_pc = pc; + best_size = c->header.size; + if ((best_size - size) <= acceptable_loss) break; + } + pc=c; + c=c->next; + } + while(NULL!=c); + } + if (NULL==best_pc) { + rsocfl = best_c->next; + } + else { + best_pc->next=best_c->next; + } + return best_c; +} + +static int get_store_in(rsoc*c,unsigned int size) { + na_env*nae=c->nae; + fll_rsoh*pf=NULL; + fll_rsoh*f=c->free_list_of_large; + while (f != NULL) { + if (f->rsoh_field.size >= size) { + nae->store_left=f->rsoh_field.size; + nae->store=(rsoh*)f; + nae->store_chunk=c; + if (pf == NULL) { + c->free_list_of_large=f->nextflol; + } + else { + pf->nextflol=f->nextflol; + } + return 1; + } + pf = f; + f = f->nextflol; + } + return 0; +} + +char*new_na_from_chunk_list(na_env*nae,unsigned int size) { + rsoc*c=nae->chunk_list; + unsigned int csize; + while (c != NULL) { + if (get_store_in(c,size)) { + return rso_from_store(nae,size); + } + c = c->next; + } + csize=size+(sizeof(rsoc)-sizeof(rsoh)); + c=rsocfl_best_fit(csize); + if (c != NULL){ + if (c->header.size > RSOC_SIZE) { + if (c->header.size-csize > RSOC_MIN_STORE*4) { + int csize_left=c->header.size-csize; + if ((csize_left%sizeof(double))!=0) { + csize_left-=(csize_left%sizeof(double)); + csize=c->header.size-csize_left; + } + c->header.size=csize_left; + c->next=rsocfl; + rsocfl=c; + c=(rsoc*)(((char*)c)+csize_left); + c->isize=0; /* c split from a larger chunk */ + gc_add_into_gcmt((mch*)c); + c->header.amfp=(void(*)(mch*,void*))gcna_align_mark; + c->header.swfp=(void(*)(mch*))rsoc_sweep; + } + /* since objects bigger than RSOC_SIZE must be the only object in their chunk, we do not want to have + some store left after them. Therefore, we do not set csize to c->header.size in an else block + here. */ + c->header.size=csize; + } + else { + csize=c->header.size; + } + c->header.state_type=RSO_USED_CHUNK; + c->free_list_of_large=NULL; + c->nae=nae; + nae->store=(&(c->first_header)); + nae->store_left=csize-sizeof(rsoc)+sizeof(rsoh); + nae->store_chunk=c; + /* No need to register chunks with no free_list_of_large + c->next=nae->chunk_list; + nae->chunk_list=c; + */ + return rso_from_store(nae,size); + } + return NULL; +} + +/* size in bytes, including header size */ +char*new_na(na_env*nae,unsigned int size) { + if (size == 0) { +#ifdef SE_BOOST + handle(SE_HANDLE_RUNTIME_ERROR, NULL); + se_print_run_time_stack(); + exit(EXIT_FAILURE); +#else + char msg[512]; + sprintf(msg, "Bad native array size: %d.\n", size); + error0(msg, NULL); +#endif + } + if (nae->store_left>0) { + nae->store->header.size=nae->store_left; + nae->store->header.magic_flag=RSOH_FREE; + if (nae->store_left >= RSOC_MIN_STORE) { + ((fll_rsoh*)(nae->store))->nextflol=nae->store_chunk->free_list_of_large; + nae->store_chunk->free_list_of_large=((fll_rsoh*)nae->store); + } + nae->store_left=0; + } + if ((nae->store_chunk!=NULL)&&(get_store_in(nae->store_chunk,size))) { + return rso_from_store(nae,size); + } + { + char*r=new_na_from_chunk_list(nae,size); + if (r!=NULL) + return r; + } + if (rsoc_countRSOC_SIZE){ + rsoc*c; + rsoh*r; + unsigned int rounded_size= chunk_rounded(size+sizeof(rsoc)-sizeof(rsoh)); + c=((rsoc*)(se_malloc(rounded_size))); + r=(&(c->first_header)); + rsoc_count++; + *c=MRSOC; + c->isize = rounded_size; + c->header.size=rounded_size; + c->nae=nae; + /* No need to register chunks with no free_list_of_large + c->next=nae->chunk_list; + nae->chunk_list=c; + */ + gc_add_into_gcmt((mch*)c); + r->header.size=size; + (r->header.magic_flag)=RSOH_UNMARKED; + ((void)memset((r+1),0,size-sizeof(rsoh))); + return (char*)(r+1); + } + else { + rsoc_malloc(nae); + return rso_from_store(nae,size); + } + } + gc_start(); + if (size<=(nae->store_left)) { + return rso_from_store(nae,size); + } + { + char*r=new_na_from_chunk_list(nae,size); + if (r!=NULL) { + return r; + } + } + if((size+sizeof(rsoc)-sizeof(rsoh))>RSOC_SIZE){ + rsoc*c; + rsoh*r; + unsigned int rounded_size = chunk_rounded(size+sizeof(rsoc)-sizeof(rsoh)); + c=((rsoc*)(se_malloc(rounded_size))); + r=(&(c->first_header)); + rsoc_count++; + *c=MRSOC; + c->isize = rounded_size; + c->header.size=rounded_size; + c->nae=nae; + /* No need to register chunks with no free_list_of_large + c->next=nae->chunk_list; + nae->chunk_list=c; + */ + gc_add_into_gcmt((mch*)c); + r->header.size=size; + (r->header.magic_flag)=RSOH_UNMARKED; + ((void)memset((r+1),0,size-sizeof(rsoh))); + gc_update_ceils(); + return (char*)(r+1); + } + else { + rsoc_malloc(nae); + gc_update_ceils(); + return rso_from_store(nae,size); + } +} + +static void gcna_align_mark(rsoc*c,void*o) { + na_env* nae = c->nae; + fll_rsoh* f; + fll_rsoh* pf; + char* b = (char*)&(c->first_header); + + /* properly aligned ? */ + if (((((char*)o)-((char*)c))%sizeof(int)) != 0) { + return; + } + /* already marked ? */ + if ((((rsoh*)o)-1)->header.magic_flag != RSOH_UNMARKED) { + return; + } + if (((char*)o) < ((char*)(c+1))) { + return; + } + /* a large chunck ? */ + if (c->header.size > RSOC_SIZE) { + if (o == (c+1)) { + nae->gc_mark((T0*)o); + } + return; + } + pf=NULL; + f=c->free_list_of_large; + while ((f != NULL) && (f < ((fll_rsoh*)o))) { + pf=f; + f=f->nextflol; + } + if (pf == NULL) { + pf=(fll_rsoh*)b; + } + while ((((rsoh*)pf)+1) < (rsoh*)o) { + pf = ((fll_rsoh*)(((char*)pf)+pf->rsoh_field.size)); + } + if (o == (((rsoh*)pf)+1)) { + nae->gc_mark((T0*)o); + } +} + +unsigned int rsocfl_count(void) { + /* Returns the number of items in the ReSizable Object Free List. + */ + register unsigned int r=0; + register rsoc*p=rsocfl; + while (p!=NULL) { + r++; + p=p->next; + } + return r; +} + +unsigned int fsocfl_count(void) { + register unsigned int r=0; + register fsoc*p=fsocfl; + while (p!=NULL) { + r++; + p=p->next; + } + return r; +} + +void gc_dispose_before_exit(void) { + mch** p = gcmt; + mch**eogcmt=gcmt+gcmt_used; + + while (p < eogcmt) { + if (((*p)->state_type == FSO_STORE_CHUNK) || + ((*p)->state_type == FSO_USED_CHUNK)) { + ((*p)->swfp)(*p); + } + p++; + } +} + +fsoc* gc_fsoc_get1(void) { + /* Get a `fsoc' (Fixed Size Object Chunk) from the free fsoc list or + allocate a new one (using `se_malloc') only when the ceil is not + yet reached. Otherwise, call the `gc_start()' function and + return NULL. + */ + fsoc* result; + if (fsocfl != NULL) { + result = fsocfl; + fsocfl = fsocfl->next; + return result; + } + else if (fsoc_count_ceil > fsoc_count) { + result = ((fsoc*)se_malloc(FSOC_SIZE)); + fsoc_count++; + gc_add_into_gcmt((mch*)result); + return result; + } + else { + gc_start(); + return NULL; + } +} + +fsoc* gc_fsoc_get2(void) { + /* Get a `fsoc' (Fixed Size Object Chunk) or force the allocation of a + new `fsoc' (using the `se_malloc' function). Update various ceils + accordingly. + */ + fsoc* result; + if (fsocfl != NULL) { + result = fsocfl; + fsocfl=fsocfl->next; + return result; + } + else { + result = ((fsoc*)(se_malloc(FSOC_SIZE))); + fsoc_count++; + gc_update_ceils(); + gc_add_into_gcmt((mch*)result); + return result; + } +} + +#if defined(__sparc__) || defined(sparc) || defined(__sparc) +/* For SPARC architecture. + As this part contains assembly code (asm), you must not use + the flag -ansi of gcc compiler. +*/ + +void mark_loop(void) { + void** max = stack_bottom; + void** stack_pointer; + void* stack_top[2]={NULL,NULL}; + stack_pointer = stack_top; + /* Addresses decrease as the stack grows. */ + while (stack_pointer <= max) { + gc_mark(*(stack_pointer++)); + } +} + +void mark_stack_and_registers(void) { +# if defined(__sparcv9) + asm(" flushw"); +# else + asm(" ta 0x3 ! ST_FLUSH_WINDOWS"); +# endif + mark_loop(); +} + +#elif defined(__ELATE__) || defined(ELATE) +/* GNU Eiffel's VP (Virtual Processor) garbage collector for Elate. + (c) 2000 Rudi Chiarito + + Thanks to Andy Stout and Kevin Croombs at Tao Group for their + precious help! + + ChangeLog: + - 2000-06-12 Rudi Chiarito + * Version 1.0 + - 2001-01-01 Joseph Kiniry + * Integrated with new SE 0.75b + - 2001-08-10 Rudi Chiarito + * Inlined and optimised range marking + * Added some more comments + * Added conditional breakpoint in mark_stack_and_registers + - 2002-09-21 Rudi Chiarito + * Removed redundant 'ret' +*/ + +__inline__ void mark_stack_and_registers(void) +{ + + void *pointer_to_gc_mark = &gc_mark; + + __asm__ __volatile__ + ( + /* + WARNING: funky code ahead! + \t and \n are needed to make the final output easier to read + while debugging. Hopefully you'll never have to bother with all + of this. + + Registers: + p0 pointer to stack block + p1 pointer to gc_mark() + p2 scratch pointer + i0 length of current stack block + i1 scratch register + */ + +# ifdef __ELATE_SE_DEBUG_GC + "\tqcall sys/cii/breakpt,(-:-)\n" +# endif + + "\tsync\n" /* spill all the registers */ + "\tsyncreg\n" /* to the stack */ + + "\tcpy.p %0,p1\n" /* pointer to gc_mark() */ + + /* pointer to the current stack block */ + "\tcpy.p [gp+PROC_STACK],p0\n" + + /* point to last location in the block, before the descriptor */ + "\tcpy.p p0 + ([(p0 - STK_SIZE) + STK_LENGTH] - STK_SIZE - 4),p2\n" + + /* mark the contents of the current stack block */ + "\twhile p2>=sp\n" + "\t\tgos p1,(p2 : -)\n" + "\t\tsub.p 4,p2\n" + "\tendwhile\n" + + /* now scan other blocks (if any) */ + + "\tloop\n" + "\t\tcpy.p [p0 - STK_SIZE + STK_LINK],p0\n" /* get next block */ + "\t\tbreakif p0=NULL\n" + + /* point to last location in the block, before the descriptor */ + "\t\tcpy.p p0 + ([(p0 - STK_SIZE) + STK_LENGTH] - STK_SIZE - 4),p2\n" + + /* mark this block */ + "\t\twhile p2>=p0\n" + + "\t\t\tgos p1,(p2 : -)\n" + "\t\t\tsub.p 4,p2\n" + "\t\tendwhile\n" + "\tendloop\n" + + : /* no output */ + : "p" (pointer_to_gc_mark) + : "p0", "p1", "p2", "i0" + ); +} + +#elif defined(__hppa__) || defined(__hppa) || defined(__hp9000) || \ + defined(__hp9000s300) || defined(hp9000s300) || \ + defined(__hp9000s700) || defined(hp9000s700) || \ + defined(__hp9000s800) || defined(hp9000s800) || defined(hp9000s820) + +/**************************************************************************** + * Generic code for architectures where addresses increase as the stack grows. + ****************************************************************************/ + +void mark_stack_and_registers(void){ + void** max = stack_bottom; + JMP_BUF registers; /* The jmp_buf buffer is in the C stack. */ + void**stack_pointer; /* Used to traverse the stack and registers assuming + that `setjmp' will save registers in the C stack. + */ + + (void)SETJMP(registers); /* To fill the C stack with registers. */ + stack_pointer = (void**)(void*)(®isters) + ((sizeof(JMP_BUF)/sizeof(void*))-1); + /* stack_pointer will traverse the JMP_BUF as well (jmp_buf size is added, + otherwise stack_pointer would be below the registers structure). */ + +# if !defined(SE_BOOST) + if (stack_pointer < max) { + fprintf(stderr, "Wrong stack direction: your stack decrease as the stack grows (or complex stack management). Please drop an e-mail to SmartEiffel@loria.fr\n"); + exit(1); } +# endif + + while (stack_pointer >= max) { + gc_mark(*(stack_pointer--)); + } +} +#else + +/**************************************************************************** + * Generic code for architectures where addresses decrease as the stack grows. + ****************************************************************************/ + +void mark_stack_and_registers(void){ + void** max = stack_bottom; + JMP_BUF registers; /* The jmp_buf buffer is in the C stack. */ + void**stack_pointer; /* Used to traverse the stack and registers assuming + that `setjmp' will save registers in the C stack. + */ + + (void)SETJMP(registers); /* To fill the C stack with registers. */ + stack_pointer = (void**)(void*)(®isters); + +# if !defined(SE_BOOST) + if (stack_pointer > max) { + fprintf(stderr, "Wrong stack direction: the stack addresses increase as the stack grows (or complex stack management). Please drop an e-mail to SmartEiffel@loria.fr\n"); + exit(1); } +# endif + + while (stack_pointer <= max) { + gc_mark(*(stack_pointer++)); + } +} +#endif + +void x_key_info_init(XKeyInfo *info, int *min_k, int *max_k, int *num_k) { + *min_k = info->min_keycode; + *max_k = info->max_keycode; + *num_k = info->num_keys; +} + +void x_valuator_info_init(XValuatorInfo *info, int *nb_axes, int *is_absolute, int *buf_size) { + *nb_axes = info->num_axes; + *is_absolute = (info->mode == Absolute); + *buf_size = info->motion_buffer; +} + +void * x_device_init_events(XDevice * device, int * events_id) { + XEventClass * result; + + result = malloc(7 * sizeof(XEventClass)); /* see also x_device_select_events */ + DeviceKeyPress(device, events_id[0], result[0]); + DeviceKeyRelease(device, events_id[1], result[1]); + DeviceButtonPress(device, events_id[2], result[2]); + DeviceButtonRelease(device, events_id[3], result[3]); + DeviceMotionNotify(device, events_id[4], result[4]); + ProximityIn(device, events_id[5], result[5]); + ProximityOut(device, events_id[6], result[6]); + return result; +} + +void x_device_select_events(void * window, XEventClass * events_classes) { + XSelectExtensionEvent(dpy, (Window)window, events_classes, 7); +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +HINSTANCE main_hInstance; +int main_nCmdShow; +const char *CLASSNAME="Vision window"; +MSG last_message; +HDC hdc; +HWND hwnd; +PAINTSTRUCT paintstruct; +RECT windowRect; +DWORD message_thread_id; +DWORD main_thread_id; +static HANDLE message_thread_handle; +int decorated_window_x_offset; +int decorated_window_y_offset; +int decorated_window_width_offset; +int decorated_window_height_offset; +HANDLE sem_paint; +HANDLE sem_new_window; +HANDLE sem_thread_finished_work; +HANDLE sems_wait_end_paint[3]; +# ifndef WM_MOUSELEAVE +# define WM_MOUSELEAVE 0x2a3 +# endif +# define WM_MOUSEENTER (WM_USER + 5) +HWND pointer_window=NULL; +int button_swapped; + +/* This list is a ring. It is "empty" when first_message == first_free. */ +/* empty means "no message enqueued". Cells remains to avoid malloc/free. */ +/* Used for messages sent from the message's thread to the main thread. */ +struct message_list {struct message_list * next; MSG msg;}; +volatile static struct message_list *first_message; +volatile static struct message_list *first_free; + +/* This list is a ring. It is "empty" when first_cmd == first_free_cmd. */ +/* empty means "no message enqueued". Cells remains to avoid malloc/free. */ +/* Used for commands sent from the main thread to the message's thread. */ +volatile struct cmd_list *first_cmd; +volatile struct cmd_list *first_free_cmd; +HANDLE sem_cmd_ready; +HANDLE sems_wait_cmd[2]; +window_description screen_desc; + +#else +# include +Display *dpy; /* X server connection */ +int red_mask, green_mask, blue_mask; +int red_shift, blue_shift, green_shift; +XEvent last_event; +int vision_error_handler(Display *disp, XErrorEvent *err); +Atom atom_DELWIN = 0; +Atom atom_PROTOCOLS = 0; +#endif + +#ifdef WIN32 +static DWORD WINAPI MessageCallBackThread(LPVOID unused); + +static void vision_handler(se_handler_action_t action, void *data) { + switch(action) { + case SE_HANDLE_NO_MORE_MEMORY: + case SE_HANDLE_RUNTIME_ERROR: + case SE_HANDLE_DIE_WITH_CODE: + case SE_HANDLE_NORMAL_EXIT: + CloseHandle(message_thread_handle); + } +} + +static void run_first_cmd(void) { + vision_check(first_cmd != first_free_cmd); /* non empty list */ + switch (first_cmd->cmd_type) { + case SET_TITLE: + if (!*(char*)first_cmd->param2) + vision_check_call(SetWindowText ((HWND)first_cmd->param1, " ")); + else + vision_check_call(SetWindowText ((HWND)first_cmd->param1, + (char *)first_cmd->param2)); + break; + case CLEAR_AREA: + vision_check_call(InvalidateRect((HWND)first_cmd->param1, + (RECT*)(&(first_cmd->param2)), TRUE)); + break; + case MAP_WINDOW: + ShowWindow((HWND)(first_cmd->param1), first_cmd->param2); + break; + case MOVE_WINDOW: + vision_check_call(MoveWindow((HWND)first_cmd->param1, + first_cmd->param2, first_cmd->param3, + first_cmd->param4, first_cmd->param5, + first_cmd->param6)); + break; + case SET_FOCUS: + vision_check_call(SetFocus((HWND)first_cmd->param1)); + break; + } + first_cmd = first_cmd->next; +} + +void emit_event(int event, HWND window) { + MSG *msg = (MSG*)&(first_free->msg); + + msg->hwnd = window; + msg->message = event; + msg->time = timeGetTime(); + vision_check_call(GetCursorPos(&(msg->pt))); + if (first_free->next == first_message) { + struct message_list *new_cell = malloc(sizeof(struct message_list)); + new_cell->next = first_free->next; + first_free->next = new_cell; + first_free = new_cell; /* don't merge with previous line, first_free + * is the last change done and + * then the consumer may use this cell */ + } else { + first_free = first_free->next; + } + vision_check_call(ReleaseSemaphore(sem_msg_ready, 1, NULL)); +} + +static void generate_leave_enter_events(window_description* from, + window_description* to){ + if (to->marked) { + /* End recursivity case */ + window_description* wnd = from; + to->marked = 0; + if (wnd) { + while(wnd->marked) { + emit_event(WM_MOUSELEAVE, wnd->Current); + wnd->marked = 0; + wnd = wnd->parent; + }; + wnd = wnd->parent; + } + while(wnd) { + wnd->marked = 0; + wnd = wnd->parent; + }; + } else { + /* recursive call */ + generate_leave_enter_events(from, to->parent); + emit_event(WM_MOUSEENTER, to->Current); + } +} + + + +static DWORD WINAPI MessageCallBackThread(LPVOID unused) { + /* --TODO: ExitThread ? CloseHandle in the main thread ? */ + MSG local_message; + BOOL status; + + /* Send "ready" message */ + vision_check_call(PostThreadMessage(main_thread_id, WM_USER+2, 0, 0)); + + while(1){ + status = MsgWaitForMultipleObjects(2, sems_wait_cmd, FALSE, + INFINITE, QS_ALLINPUT); + if (status == WAIT_OBJECT_0 + 2) { + while(PeekMessage(&local_message, NULL, 0, 0, PM_REMOVE)) + DispatchMessage(&local_message); + } else if (status == WAIT_OBJECT_0) { + run_first_cmd(); + } else { + vision_check(status == WAIT_OBJECT_0 + 1); + /* Request to create new window */ + new_window(); + } + } + return 0; +} + +void display_error(int num) { + LPVOID lpMsgBuf; + + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, num, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); + MessageBox(NULL, lpMsgBuf, "GetLastError", MB_OK|MB_ICONINFORMATION); + LocalFree(lpMsgBuf); +} + +LRESULT CALLBACK WndProc(HWND hWnd, unsigned int iMessage, WPARAM wParam, LPARAM lParam) +{ + MSG * msg; + + switch (iMessage) { + case WM_SIZING: + { + int edge = wParam; + RECT *rect = (LPRECT)lParam; + window_description *desc = (window_description*)GetWindowLong((HWND)hWnd, GWL_USERDATA); + int width = rect->right - rect->left; + int height = rect->bottom - rect->top; + + if (edge % 3 == 1) { /* Left border control */ + if (width < desc->min_width) + rect->left -= (desc->min_width - width); + else if (width > desc->max_width) + rect->left += (width - desc->max_width); + } else if (edge % 3 == 2) { /* Right border control */ + if (width < desc->min_width) + rect->right += (desc->min_width - width); + else if (width > desc->max_width) + rect->right -= (width - desc->max_width); + } + + if (edge >= 6) { /* Bottom border control */ + if (height < desc->min_height) + rect->bottom += (desc->min_height - height); + else if (height > desc->max_height) + rect->bottom -= (height - desc->max_height); + } else if (edge >= 3) { /* Top border control */ + if (height < desc->min_height) + rect->top -= (desc->min_height - height); + else if (height > desc->max_height) + rect->top += (height - desc->max_height); + } + + return TRUE; + } + case WM_ERASEBKGND: + return 0; + case WM_PAINT: + hwnd = hWnd; + hdc = BeginPaint(hWnd, &paintstruct); + vision_check(hdc); + break; + /* no return !!! */ + case WM_MOUSEMOVE: + if (hWnd != pointer_window) { + window_description* from=NULL; + window_description* to; + RECT rect; + vision_check_call(GetClientRect(hWnd, &rect)); + if (!(LOWORD(lParam)<0 || LOWORD(lParam)>=rect.right || HIWORD(lParam)<0 || HIWORD(lParam)>=rect.bottom)) { + if (pointer_window) { + window_description* wnd; + from = wnd = (window_description*)GetWindowLong((HWND)pointer_window, + GWL_USERDATA); + do { + wnd->marked = 1; + wnd = wnd->parent; + } while (wnd); + } else + screen_desc.marked = 1; + to = (window_description*)GetWindowLong(hWnd, GWL_USERDATA); + generate_leave_enter_events(from, to); + pointer_window = hWnd; + } + } else { + RECT rect; + vision_check_call(GetClientRect(hWnd, &rect)); + if (LOWORD(lParam)<0 || LOWORD(lParam)>=rect.right || HIWORD(lParam)<0 || HIWORD(lParam)>=rect.bottom) + { + window_description* wnd; + wnd = (window_description*)GetWindowLong((HWND)pointer_window, + GWL_USERDATA); + emit_event(WM_MOUSELEAVE, hWnd); + pointer_window = wnd->parent->Current; + } + } + break; + /* no return !!! */ + case WM_KILLFOCUS: /* --TODO: it's keyboard focus. Useful ? */ + break; + /* no return !!! */ + case WM_NCACTIVATE: + if ((BOOL)wParam) + return DefWindowProc(hWnd, iMessage, wParam, lParam); + else + return TRUE; + case WM_ACTIVATE: + if (LOWORD(wParam)) + return DefWindowProc(hWnd, iMessage, wParam, lParam); + else { + window_description* desc; + desc = (window_description*)GetWindowLong((HWND) lParam, GWL_USERDATA); + /* --TODO: check if this window belongs to this program instead of just testing if desc is not null (list all toplevel windows?) */ + if (!desc || desc->decorated) { + DefWindowProc(hWnd, WM_NCACTIVATE, FALSE, lParam); + return DefWindowProc(hWnd, iMessage, wParam, lParam); + } else + return FALSE; + } + case WM_LBUTTONDOWN: + case WM_MBUTTONDOWN: + case WM_RBUTTONDOWN: + SetCapture(hWnd); + break; + /* no return !!! */ + case WM_LBUTTONUP: + case WM_MBUTTONUP: + case WM_RBUTTONUP: + ReleaseCapture(); + break; + /* no return !!! */ + case WM_MOUSEWHEEL: + { + /* Search window under mouse cursor and convert coordinates */ + POINT p; + p.x = (short) LOWORD(lParam); + p.y = (short) HIWORD(lParam); + hWnd = WindowFromPoint(p); + ScreenToClient(hWnd, &p); + lParam = POINTTOPOINTS(p); + } + break; + /* no return !!! */ + case WM_KEYDOWN: + case WM_KEYUP: + case WM_SETFOCUS: + case WM_SHOWWINDOW: + case WM_CLOSE: + case WM_QUIT: + case WM_DESTROY: + case WM_MOVE: + case WM_SIZE: + break; + default: + return DefWindowProc(hWnd, iMessage, wParam, lParam); + } + msg = (MSG*)&(first_free->msg); + + msg->hwnd = hWnd; + msg->message = iMessage; + msg->wParam = wParam; + msg->lParam = lParam; + msg->time = timeGetTime(); + vision_check_call(GetCursorPos(&(msg->pt))); + + if (first_free->next == first_message) { + struct message_list *new_cell = malloc(sizeof(struct message_list)); + new_cell->next = first_free->next; + first_free->next = new_cell; + first_free = new_cell; /* don't merge with previous line, first_free + * is the last change done and + * then the consumer may use this cell */ + } else { + first_free = first_free->next; + } + vision_check_call(ReleaseSemaphore(sem_msg_ready, 1, NULL)); + if (iMessage == WM_PAINT) { + int status; + + /* Wait for "endpaint" message from appli */ + do { + status = WaitForMultipleObjects(3, sems_wait_end_paint, + FALSE, INFINITE); + vision_check(status != WAIT_FAILED); + if (status == WAIT_OBJECT_0 + 2) { + run_first_cmd(); + } else if (status == WAIT_OBJECT_0 + 1) { + /* Request to create new window */ + new_window(); + } + } while (status != WAIT_OBJECT_0); + EndPaint(hWnd, &paintstruct); + hwnd = NULL; + hdc = NULL; + } + return 0; +} +#else +int vision_error_handler(Display *disp, XErrorEvent *err) { + char buf[128]; + + /* in case the error occurred during the Grab command... */ + XUngrabServer(disp); + XUngrabButton(disp, (unsigned int) AnyButton, 0, DefaultRootWindow(disp)); + se_print_run_time_stack(); + XGetErrorText(disp, err->error_code, buf, 128); + fprintf(SE_ERR,"X Error: %s.\n",buf); + fprintf(SE_ERR," Major Opcode: %d\n",err->request_code); + + exit(-1); +} +#endif + +#ifndef WIN32 +int higher_bit(int val) { + int i=0; + while (val >= 0) { + val = val << 1; + i++; + } + return 32-i; +} +#endif + +int _basic_vision_init(void) { +#ifdef WIN32 + + WNDCLASS WndClass; + NONCLIENTMETRICS ncm; + + main_hInstance = (HINSTANCE)GetModuleHandle(NULL); + main_nCmdShow = SW_SHOWDEFAULT; /* First window display mode: minimized, normal, + * maximized, hide, ... */ + + /* Initialize the lists to empty state. */ + first_message = first_free = malloc(sizeof(struct message_list)); + first_free->next = (struct message_list *)first_message; + first_cmd = first_free_cmd = malloc(sizeof(struct cmd_list)); + first_free_cmd->next = (struct cmd_list *)first_cmd; + sem_paint = CreateSemaphore(NULL, 0, 1, NULL); + sem_new_window = CreateSemaphore(NULL, 0, 1, NULL); + sem_thread_finished_work = CreateSemaphore(NULL, 0, 1, NULL); + sem_msg_ready = CreateSemaphore(NULL, 0, INT32_MAX, NULL); + sem_cmd_ready = CreateSemaphore(NULL, 0, INT32_MAX, NULL); + sems_wait_end_paint[0] = sem_paint; + sems_wait_end_paint[1] = sem_new_window; + sems_wait_end_paint[2] = sem_cmd_ready; + sems_wait_cmd[0] = sem_cmd_ready; + sems_wait_cmd[1] = sem_new_window; + screen_desc.Current = NULL; + screen_desc.parent = NULL; + button_swapped = GetSystemMetrics(SM_SWAPBUTTON); + vision_check(sem_paint); + vision_check(sem_new_window); + vision_check(sem_msg_ready); + vision_check(sem_cmd_ready); + + ncm.cbSize = sizeof(ncm); + vision_check_call(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, + sizeof(ncm), &ncm, 0)); + decorated_window_x_offset = GetSystemMetrics(SM_CXFRAME); + decorated_window_width_offset = 2* decorated_window_x_offset; + decorated_window_y_offset = ncm.iCaptionHeight+decorated_window_x_offset+1; + decorated_window_height_offset = decorated_window_y_offset + decorated_window_x_offset; + + main_thread_id = GetCurrentThreadId(); + message_thread_handle = CreateThread(NULL,100 /* ??? */, + MessageCallBackThread, + NULL, 0, &message_thread_id); + vision_check(message_thread_handle); + vision_check(message_thread_id); + + /* Wait for "ready" message from the thread */ + vision_check_call(GetMessage(&last_message, NULL, WM_USER+2, WM_USER+2)); + register_handler(vision_handler); + memset(&WndClass, 0, sizeof(WndClass)); + WndClass.cbClsExtra = 0; + WndClass.cbWndExtra = sizeof(window_description *); /* extra bytes allocated for window instance <= 40 for Win95, advice: no more than 4 */ + WndClass.hbrBackground = GetStockObject(BLACK_BRUSH); + WndClass.hCursor = LoadCursor(NULL, IDC_ARROW); + WndClass.hIcon = LoadIcon(main_hInstance, NULL); + WndClass.hInstance = main_hInstance; + WndClass.lpfnWndProc = WndProc; + WndClass.lpszClassName = CLASSNAME; + WndClass.style = CS_HREDRAW | CS_VREDRAW; /* --TODO: 0 to suppress complete redraw on WM_SIZE and WM_MOVE */ /* use CS_PARENTDC? */ + if(!RegisterClass(&WndClass)) + exit(0); + + return -1; +#else + Visual *visual; + /* + * Open the display using the $DISPLAY environment variable to locate + * the X server. See Section 2.1. + */ + if ((dpy = XOpenDisplay(NULL)) == NULL) { + fprintf(stderr, "Can't open \"%s\"\n", XDisplayName(NULL)); + return (0); + } +# ifdef VISION_DEBUG + XSynchronize(dpy, True); +# endif + XSetErrorHandler(vision_error_handler); + + visual = DefaultVisual(dpy,DefaultScreen(dpy)); + red_mask = visual->red_mask; + green_mask = visual->green_mask; + blue_mask = visual->blue_mask; + if (red_mask) { + red_shift = higher_bit(red_mask) - 16; + blue_shift = higher_bit(blue_mask) - 16; + green_shift = higher_bit(green_mask) - 16; + } + + return(ConnectionNumber(dpy)); +#endif +} + +int _basic_vision_character() { + /* --TODO: unicode result ! */ + int res; + +#ifdef WIN32 + char chars[2]; + unsigned char keystate[256]; + GetKeyboardState(keystate); + ToAscii((int)last_message.wParam,(HIWORD(last_message.lParam)) & 0xFF, + keystate,(LPWORD)chars,0); + res = (int)chars[0]; +#else + XKeyEvent* key_event = (XKeyEvent*)&last_event; + char r; + + if(XLookupString(key_event, &r, 1, NULL, NULL)) + res = (int)r; + else + res= 0; +#endif + return res; +} + +int _basic_vision_key() { + int res; + +#ifdef WIN32 + res = _basic_vision_character(); +#else + XKeyEvent* key_event = (XKeyEvent*)&last_event; + + res = (int)XKeycodeToKeysym(dpy, key_event->keycode, 0); + if(res == NoSymbol) + res = 0; +#endif + return res; +} + +int basic_vision_get_keysym(char* string) { + int res = 0; +#ifdef WIN32 +#else + res = (int)XStringToKeysym(string); + if(res == NoSymbol) + res = 0; +#endif + return res; +} + +#ifdef WIN32 +static int exist_message(UINT type, HWND window) { + struct message_list *msg = (struct message_list *)first_message; + + while (msg != first_free) + { + if ((msg->msg.message == type) && (msg->msg.hwnd == window)) + return 1; + msg = msg->next; + } + return 0; +} +#endif + +static int get_next_event(void); +int _basic_vision_next_event(void) { + int result; + while((result=get_next_event())==-2); + return result; +} + +static int get_next_event(void) { + /* return event number, -1 if no event is available, -2 if new call to + * this function is needed. */ +#ifdef WIN32 + if (last_message.message==WM_PAINT) { + SetBkMode(hdc, TRANSPARENT); + TextOut(hdc, 0, 0, " ", 1); /* THIS IS AWFUL HACK FOR WINDOWS 2000 */ + /* --TODO: search if some "flushing" is required for Windows 2000 */ + vision_check_call(ReleaseSemaphore(sem_paint, 1, NULL)); + last_message.message = -1; + } + if (first_message != first_free){ /* non empty list */ + last_message = first_message->msg; + first_message = first_message->next; + vision_check_call(WaitForSingleObject(sem_msg_ready, INFINITE) == WAIT_OBJECT_0); /* never wait, only decrease sem value here */ + } else { + return -1; + } + /*printf("Message %d received\n",last_message.message);*/ + switch (last_message.message) + { + case WM_KEYDOWN: + last_message.hwnd = pointer_window; + return 2; + case WM_KEYUP: + last_message.hwnd = pointer_window; + return 3; + case WM_MOUSEENTER: + return 7; + case WM_MOUSELEAVE: + return 8; + case WM_SETFOCUS: /* --TODO: it's keyboard focus. Useful ? */ + return -2; /*9*/ + case WM_KILLFOCUS: /* --TODO: it's keyboard focus. Useful ? */ + return -2; /*10*/ + case WM_PAINT: + if (paintstruct.fErase) + { + window_description *desc = (window_description*)GetWindowLong((HWND)last_message.hwnd, GWL_USERDATA); + /* --TODO: handle pixmap case */ + vision_check_call(FillRect(hdc, &(paintstruct.rcPaint), + desc->background)); + } + return 12; + /* unmaped ? */ + case WM_SHOWWINDOW: + return 19; + case WM_LBUTTONDOWN: + return 40; + case WM_MBUTTONDOWN: + return 41; + case WM_RBUTTONDOWN: + return 42; + case WM_MOUSEWHEEL: + return ((short)HIWORD(last_message.wParam)>0)?43:44; /* --TODO: 120 value...*/ + case WM_LBUTTONUP: + return 50; + case WM_MBUTTONUP: + return 51; + case WM_RBUTTONUP: + return 52; + /* fully_visible ? */ + /* partially_visible ? */ + /* not_visible ? */ + case WM_CLOSE: + /* user requested to close the window, call DestroyWindow if agree */ + return 63; + case WM_QUIT: + /* application requested to terminate via PostQuitMessage */ + printf("Quit !!! \n"); + return 63; + case WM_DESTROY: + /* window is being destroyed. --TODO:process clipboard ! */ + printf("Destroy !!! \n"); + return 63; + case WM_MOUSEMOVE: + return 100; + case WM_MOVE: + /* --TODO: remove ? */ + if (exist_message(WM_MOVE, last_message.hwnd)) return -2; + windowRect.left = (int) LOWORD(last_message.lParam); + windowRect.top = (int) HIWORD(last_message.lParam); + return 102; + case WM_SIZE: + /* --TODO: remove ? */ + if (exist_message(WM_SIZE, last_message.hwnd)) return -2; + windowRect.right = (int) LOWORD(last_message.lParam); + windowRect.bottom = (int) HIWORD(last_message.lParam); + return 103; + case 280: + DefWindowProc(last_message.hwnd, last_message.message, last_message.wParam, last_message.lParam); + return -2; /* ??????? */ + default: + fprintf(stderr,"Event number %d not handled.\n", last_message.message); + DefWindowProc(last_message.hwnd, last_message.message, last_message.wParam, last_message.lParam); + return -2; + } +#else + XEvent peek; + + /* if (XEventsQueued(dpy,QueuedAlready)) { */ + /*if (XEventsQueued(dpy,QueuedAfterReading)) { */ + if (XEventsQueued(dpy,QueuedAfterFlush)) { + XNextEvent(dpy,&last_event); + switch (last_event.type) + { + case 4: + /* For button press, events 40, 41, ... */ + return 39+((XButtonEvent*)&last_event)->button; + case 5: + /* For button release, events 50, 51, ... */ + return 49+((XButtonEvent*)&last_event)->button; + case 6: + return 100; + case 7: + if (((XCrossingEvent*)&last_event)->detail == NotifyInferior) + return -2; + else + return 7; + case 8: + if (((XCrossingEvent*)&last_event)->detail == NotifyInferior) + return -2; + else + return 8; + case 9: + case 10: + ((XFocusChangeEvent*)&last_event)->window = DefaultRootWindow(dpy); + return(last_event.type); + case 15: + return 60+((XVisibilityEvent*)&last_event)->state; + case 22: + while (XCheckTypedWindowEvent(dpy, last_event.xany.window, + 22, &last_event)) + ; + return 101; + /* case 25: + *{ + *XResizeRequestEvent*e=(XResizeRequestEvent*)&last_event; + *printf("Request : %d, %d\n",e->width,e->height); + *XResizeWindow(dpy, e->window, e->width, (e->height+4)&~7); + *} + * + *return 25; + */ + case 33: /* ClientMessage */ + if ((((XClientMessageEvent*)&last_event)->message_type==atom_PROTOCOLS) + && + (((XClientMessageEvent *)&last_event)->data.l[0] == atom_DELWIN)) { + /* it's a WM_DELETE_WINDOW event */ + return 63; + } + + return 33; + case 3: + if(XPending(dpy)) { + /* If the next event is a KeyPressed, than we have a repeat */ + XPeekEvent(dpy, &peek); + if(peek.type == 2 && peek.xkey.keycode == last_event.xkey.keycode && peek.xkey.time == last_event.xkey.time) { + XNextEvent(dpy, &peek); + return 2; + } + return 3; + } + default: + if (last_event.type >= LASTEvent) { + return 110; /* Extension */ + } else { + return last_event.type; + } + } + } else return -1; +#endif +} + + +#ifndef WIN32 +/* X help function */ +struct color_dist{ + int index; /* color index in colormap */ + int distance; /* distance from searched color */ +}; + +static int color_cmp(const void* a, const void* b) { + return (((struct color_dist *)a)->distance - ((struct color_dist *)b)->distance); +} + +#define nb_col 256 /* visual dependant ? */ + +static void * search_X_color(int *r, int *g, int *b) { + static XColor * c_map = NULL; + static struct color_dist * distances = NULL; + XColor *xcol; + int status; + int i; + int x, y, z; + int rmean; + + if (!c_map) c_map = malloc(nb_col*sizeof(XColor)); + if (!distances) distances = malloc(nb_col*sizeof(struct color_dist)); + for (i=0; i>5; + x=(*r - c_map[i].red)>>4; + y=(*g - c_map[i].green)>>4; + z=(*b - c_map[i].blue)>>4; + distances[i].distance=(((((8192+rmean)*x)>>10)*x)>>2) + 4*y*y + (((((12287-rmean)*z)>>10)*z)>>2); + } + qsort(distances, nb_col, sizeof(struct color_dist), color_cmp); + /* printf("searched : %d %d %d, found : %d %d %d\n",*r >> 8, *g >> 8, *b >> 8, c_map[distances->index].red >> 8, c_map[distances->index].green >> 8, c_map[distances->index].blue >> 8); */ + + for (status=0, i=0; (status==0) && (ired; + *g = xcol->green; + *b = xcol->blue; + return (void*)xcol->pixel; +} + + +static int search_X_color2(int *r, int *g, int *b) { + static XcmsColor * c_map = NULL; + static XColor * rgb_c_map = NULL; + static struct color_dist * distances = NULL; + XcmsColor search; + XColor xcol; + int status; + int i; + + if (!distances) distances = malloc(nb_col*sizeof(struct color_dist)); + if (!c_map) { + c_map = malloc(nb_col*sizeof(XcmsColor)); + for (i=0; i180) d = 360.0 - d; + if (d<0) exit(0); + d = d * abs(search.spec.TekHVC.C)/10; + d += abs(search.spec.TekHVC.C - c_map[i].spec.TekHVC.C); + d += abs(search.spec.TekHVC.V - c_map[i].spec.TekHVC.V); + distances[i].distance = (int)d; + } + qsort(distances, nb_col, sizeof(struct color_dist), color_cmp); + for (status=0, i=0; (status==0) && (i>8) + 25)/51))*51)<<8; + xcol.green = (((int)(((*g>>8) + 25)/51))*51)<<8; + xcol.blue = (((int)(((*b>>8) + 25)/51))*51)<<8; + status = XAllocColor(dpy,DefaultColormap(dpy,DefaultScreen(dpy)),&xcol); + if (status) + return (void*)(xcol.pixel); + else + return search_X_color(r, g, b); + } +} +#endif + + +void *basic_vision_get_color(int *r, int *g, int *b) { +#ifdef WIN32 + return (void*)RGB((*r>>8), (*g>>8), (*b>>8)); +#else + if (red_mask) + return (void*)(long)((((red_shift>0)?(*r)<>-red_shift)&red_mask) | + (((green_shift>0)?(*g)<>-green_shift)&green_mask) | + (((blue_shift>0)?(*b)<>-blue_shift)&blue_mask)); + else + return get_color_from_server(r, g, b); +#endif +} + +/* +XGrabPointer(dpy, win, 0, ButtonPressMask|ButtonReleaseMask|EnterWindowMask|LeaveWindowMask| PointerMotionMask|Button1MotionMask|Button2MotionMask|Button3MotionMask|Button4MotionMask|Button5MotionMask|ButtonMotionMask, GrabModeAsync, GrabModeAsync, None , None, 0) +*/ + +int vision_available(void) { +#ifdef WIN32 + return 1; +#else + return getenv("DISPLAY") != NULL; +#endif +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#if defined __USE_POSIX || defined __unix__ || defined _POSIX_C_SOURCE +/* macro read is used of read_stdin */ + +void io_copy (char*source, char*target) { + /* We use the low-level descriptor functions rather than stream-oriented functions. + * This allows us to copy the file's permissions. */ + + int src; + int tgt; + struct stat info; + static char *buffer = NULL; + static int bufsize = 0; + int read_count, write_count, written; + + src=open (source, O_RDONLY); + if (fstat (src, &info)) + return; /* Ooops */ + if (bufsize < info.st_blksize) + buffer=se_realloc (buffer, info.st_blksize); + tgt=creat (target, info.st_mode); + do { + read_count = read (src, buffer, info.st_blksize); + write_count = 0; written = 0; + while ((write_count < read_count) && (written >= 0)) + { + written = write (tgt, buffer + write_count, read_count - write_count); + write_count += written; + } + } while ((read_count > 0) && (written >= 0)); + close (src); + close (tgt); +} + +int io_same_physical_file(char*path1,char*path2) { + struct stat info1, info2; + if (stat(path1, &info1)) + return 0; /* oops */ + if (stat(path2, &info2)) + return 0; /* oops */ + return (info1.st_dev == info2.st_dev) && (info1.st_ino == info2.st_ino); +} + +#else +#define IO_COPY_BUFSIZE 4096 + +int read_stdin(EIF_CHARACTER *buffer, int size) { + int c; + c = getc(stdin); + if (c==EOF) + return 0; + *buffer = (EIF_CHARACTER)c; + return 1; +} + +void io_copy(char*source, char*target) { + static char *buffer = NULL; + int read_count; + FILE*src=fopen(source, "rb"); + FILE*tgt=fopen(target, "wb"); + + if(!buffer) + buffer = (char*)se_malloc(IO_COPY_BUFSIZE); + + while ((read_count = fread(buffer, 1, IO_COPY_BUFSIZE, src)), read_count) { + fwrite(buffer, 1, read_count, tgt); + } + fclose(src); + fclose(tgt); +} + +int io_same_physical_file(char*path1,char*path2) { + /* default implementation returns true only if the paths are the same */ + return !strcmp(path1, path2); +} +#endif + +int io_file_exists(char*source) { + FILE*src=fopen(source, "rb"); + if (src!=NULL) { + fclose(src); + return 1; + } + else { + return (errno != ENOENT); + } +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +EIF_REAL_64 time_difftime(time_t t2, time_t t1) { + return difftime((time_t)t2, (time_t)t1); +} + +EIF_INTEGER time_getyear(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_year + 1900; + } + else { + return (localtime((time_t *)(&t)))->tm_year + 1900; + } +} + +EIF_INTEGER time_getmonth(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_mon + 1; + } + else { + return (localtime((time_t *)(&t)))->tm_mon + 1; + } +} + +EIF_INTEGER time_getday(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_mday; + } + else { + return (localtime((time_t *)(&t)))->tm_mday; + } +} + +EIF_INTEGER time_gethour(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_hour; + } + else { + return (localtime((time_t *)(&t)))->tm_hour; + } +} + +EIF_INTEGER time_getminute(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_min; + } + else { + return (localtime((time_t *)(&t)))->tm_min; + } +} + +EIF_INTEGER time_getsecond(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_sec; + } + else { + return (localtime((time_t *)(&t)))->tm_sec; + } +} + +EIF_INTEGER time_getwday(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_wday; + } + else { + return (localtime((time_t *)(&t)))->tm_wday; + } +} + +EIF_INTEGER time_getyday(time_t t, EIF_INTEGER m) { + if (m == 1) { + return (gmtime((time_t *)(&t)))->tm_yday; + } + else { + return (localtime((time_t *)(&t)))->tm_yday; + } +} + +EIF_BOOLEAN time_is_summer_time_used(time_t t) { + return (EIF_BOOLEAN)(((localtime((time_t *)(&t)))->tm_isdst) != 0); +} + +EIF_INTEGER_64 time_mktime(EIF_INTEGER year, + EIF_INTEGER mon, + EIF_INTEGER mday, + EIF_INTEGER hour, + EIF_INTEGER min, + EIF_INTEGER sec) { + struct tm tm_buf; + + tm_buf.tm_year = (year - 1900); + tm_buf.tm_mon = (mon - 1); + tm_buf.tm_mday = mday; + tm_buf.tm_hour = hour; + tm_buf.tm_min = min; + tm_buf.tm_sec = sec; + tm_buf.tm_isdst = -1; + + return (EIF_INTEGER_64)mktime(&tm_buf); +} + +void time_add_second(EIF_INTEGER_64 *t, EIF_INTEGER s) { + *t += s; +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +void sprintf_real_64(EIF_CHARACTER* b, EIF_CHARACTER m, int32_t f, real64_t r) { + char fmt[32]; + fmt[0]='%'; + fmt[1]='.'; + sprintf(fmt+2, "%d%c", f, m); + sprintf((char*)b, fmt, r); +} + +void sprintf_real_extended(EIF_CHARACTER* b, EIF_CHARACTER m, int32_t f, real_extended_t r) { + char fmt[32]; + fmt[0]='%'; + fmt[1]='.'; + sprintf(fmt+2, "%dL%c", f, m); + sprintf((char*)b, fmt, r); +} + + +int x_query_extension(char * extension_name) +{ + int major_opcode, first_event_code, first_error_code; + + return XQueryExtension(dpy, extension_name, &major_opcode, &first_event_code, &first_error_code); +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +int win32_msg=0; +int win32_msg_ready=FALSE; +HANDLE sem_msg_ready; +#endif + +EIF_POINTER _sequencer_create_set(void) { + void * mem; + mem = malloc(sizeof(fd_set)); + if (!mem) { + fprintf(stderr, "Error in malloc for select, exiting\n"); + exit(1); + } + return mem; +} + +int sequencer_wait(int n, fd_set *read_set, int read_size, fd_set *write_set, int write_size, fd_set *exception_set, int exception_size, int s, int us){ + struct timeval tv; + int ret=0; + + tv.tv_sec = s; + tv.tv_usec = us; +#ifndef WIN32 + if (select(n, read_set, write_set, exception_set, &tv) == -1) + ret = -1; +#else + if (win32_msg == 0) { + if (n==0) + Sleep(s*1000+us/1000); + else { + if (select(n, (read_size?read_set:NULL), (write_size?write_set:NULL), (exception_size?exception_set:NULL), &tv) == -1) + ret = -1; + } + } else { + if (WaitForSingleObject(sem_msg_ready, 0) == WAIT_OBJECT_0) { + ReleaseSemaphore(sem_msg_ready, 1, NULL); + win32_msg_ready = TRUE; + } else { + if ((s != 0) || (us != 0)) { + HANDLE pHandles[MAXIMUM_WAIT_OBJECTS]; + int nCount = 0; + int to; + int i; + + if (s>2) { + /* Never wait more than 2 seconds in case race condition occured */ + to = 2000; + } else { + to = 1000*s + us/1000; + } + pHandles[nCount++] = sem_msg_ready; + for (i = read_set->fd_count-1; i >= 0; i--) + pHandles[nCount++] = (HANDLE)read_set->fd_array[i]; + for (i = write_set->fd_count-1; i >= 0; i--) + pHandles[nCount++] = (HANDLE)write_set->fd_array[i]; + ret = WaitForMultipleObjects(nCount, pHandles, FALSE, to); + if (ret == WAIT_OBJECT_0) { + ReleaseSemaphore(sem_msg_ready, 1, NULL); + win32_msg_ready = TRUE; + } + if (ret != WAIT_TIMEOUT) { + ret -= WAIT_OBJECT_0; + if (ret < 0 || ret >= nCount) { + fprintf(stderr, "Error in WaitForMultipleObjects\n"); + ret = -1; + } + } + } + if (n) { + struct timeval nowait={0,0}; + /* use read_size-1 because win32_msg was counted as read fd */ + if (select(n, ((read_size-1)?read_set:NULL), (write_size?write_set:NULL), (exception_size?exception_set:NULL),&nowait) == -1) + ret = -1; + } + } + } +#endif + return ret; +} +struct _channel { + Channel next; + HANDLE fd; + void *data; + int tobedeleted; + ChannelHandleDelete handle_delete; + ChannelHandleRead handle_read; +}; + + +void * eiffel_ivy_object; +void * eiffel_up_fct; +void * eiffel_down_fct; +void * eiffel_callback_fct; + +void IvyChannelInit(void) { + /* Do not exit when others core-dump */ + signal (SIGPIPE, SIG_IGN); +} + +Channel IvyChannelAdd (HANDLE fd, void *data, + ChannelHandleDelete handle_delete, + ChannelHandleRead handle_read + ) { + return ((void * (*)(void*, int, void*, void*, void*))eiffel_up_fct)(eiffel_ivy_object, fd, data, handle_read, handle_delete); +} + +void IvyChannelRemove (Channel channel) { + ((void (*)(void*, void*))eiffel_down_fct)(eiffel_ivy_object, channel); +} + +void plugin_read_callback(IvyClientPtr app, void *user_data, int argc, char **argv ) { + ((void (*)(void*, void*, int, char**))eiffel_callback_fct)(eiffel_ivy_object, user_data, argc, argv); +} + +void ivy_init(char * application_name, char * ready_text, void * eiffel_object, void * channel_up_callback, void * channel_down_callback, void * agent_call_callback) { + eiffel_ivy_object = eiffel_object; + eiffel_up_fct = channel_up_callback; + eiffel_down_fct = channel_down_callback; + eiffel_callback_fct = agent_call_callback; + + IvyInit(application_name, ready_text, NULL, NULL, NULL, NULL); +} + +void * bind_message(char * pattern, void * agent) { + IvyBindMsg(plugin_read_callback, agent, "%s", pattern); +} + +void IvyChannelStop (void) +{ +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +EIF_INTEGER basic_microsecond_microsecond = 0; +EIF_INTEGER_64 basic_microsecond_time = 0; + +void _basic_microsecond_update(void) { +#ifndef WIN32 + struct timeval t; + + gettimeofday (&t, NULL); + basic_microsecond_time = t.tv_sec; + basic_microsecond_microsecond = t.tv_usec; +#else + static DWORD ref_uptime = -1; /* max value as ref_uptime is unsigned */ + static time_t ref_time; + DWORD uptime; + + /* uptime = timeGetTime();*/ + uptime = GetTickCount(); + + if (uptime < ref_uptime) { + /* !!! this test manages first call AND 50th day ;-) */ + ref_uptime = uptime; + time(&ref_time); + } + + basic_microsecond_time = ref_time + (uptime - ref_uptime)/1000; + basic_microsecond_microsecond = ((uptime - ref_uptime) % 1000) * 1000; +#endif +} +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +const char *WINNAME="Window app"; /* --TODO: use exe name */ +#endif + +#ifdef WIN32 +static HWND new_window_handle; +static int new_window_x, new_window_y, new_window_width, new_window_height; +static int new_window_decorate; +static void * new_window_parent; + +void new_window(void) { + /* --TODO: replace CLASSNAME with ATOM registred with GlobalAddAtom, see RegisterClass too */ + /* --TODO: add WS_CLIPCHILDREN ? WS_CLIPSIBLINGS ? */ + window_description *desc; + + if (new_window_parent) + new_window_handle = CreateWindow(CLASSNAME, WINNAME, WS_CHILD, + new_window_x, new_window_y, + new_window_width, new_window_height, + (HWND)new_window_parent, NULL, + main_hInstance, NULL); + else + if (new_window_decorate) + new_window_handle = CreateWindow(CLASSNAME, WINNAME, WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, + new_window_width + decorated_window_width_offset, + new_window_height + decorated_window_height_offset, + NULL, NULL, main_hInstance, NULL); + else + { + LONG style; + new_window_handle = CreateWindowEx(WS_EX_TOOLWINDOW, CLASSNAME, WINNAME, + WS_POPUP | WS_CLIPCHILDREN | + WS_CLIPSIBLINGS, + new_window_x, new_window_y, + new_window_width, new_window_height, + NULL, NULL, main_hInstance, NULL); + style = GetWindowLong (new_window_handle, GWL_STYLE); + + /*style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED + |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER + |WS_SYSMENU); + SetWindowLong (new_window_handle, GWL_STYLE, style); + SetWindowPos (new_window_handle, HWND_TOPMOST , 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | + SWP_NOSIZE);*/ + } + /* new_window_handle = CreateWindow(CLASSNAME, WINNAME, WS_POPUP | + WS_CLIPCHILDREN | WS_CLIPSIBLINGS, + CW_USEDEFAULT, CW_USEDEFAULT, + new_window_width, + new_window_height, + NULL, NULL, main_hInstance, NULL); + */ + vision_check(new_window_handle); + if (!new_window_handle) display_error(GetLastError()); + desc = malloc(sizeof(window_description)); + desc->Current = new_window_handle; + + desc->background = CreateSolidBrush(RGB(255, 255, 255)); + vision_check(desc->background); + desc->decorated = new_window_decorate; + desc->parent = (new_window_parent?(window_description*)GetWindowLong((HWND)new_window_parent, GWL_USERDATA):&screen_desc); + desc->marked = 0; + SetWindowLong(new_window_handle, GWL_USERDATA, (long int)desc); + /* signal work done */ + vision_check_call(ReleaseSemaphore(sem_thread_finished_work, 1, NULL)); +} + + +void move_window(HWND window, int x, int y, int w, int h, BOOL b) { + first_free_cmd->cmd_type = MOVE_WINDOW; + first_free_cmd->param1 = (int)window; + first_free_cmd->param2 = x; + first_free_cmd->param3 = y; + first_free_cmd->param4 = w; + first_free_cmd->param5 = h; + first_free_cmd->param6 = b; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); +} +#endif + +void * basic_window_create(int x, int y, int width, int height, void * parent, int decorate) +{ +#ifdef WIN32 + new_window_x = x; + new_window_y = y; + new_window_width = width; + new_window_height = height; + new_window_parent = parent; + new_window_decorate = decorate; + + vision_check_call(ReleaseSemaphore(sem_new_window, 1, NULL)); + /* Wait for "ready" message from the thread */ + vision_check_call(WaitForSingleObject(sem_thread_finished_work, INFINITE) == WAIT_OBJECT_0); + return (void *)new_window_handle; +#else + Window win; /* Window ID */ + unsigned long fg, bg, bd; /* Pixel values */ + unsigned long bw; /* Border width */ + XSizeHints xsh; /* Size hints for window manager */ + + /*XSetWindowAttributes attr;*/ + /* + * Select colors for the border, the window background, and the + * foreground. + */ + bd = WhitePixel(dpy, DefaultScreen(dpy)); + bg = BlackPixel(dpy, DefaultScreen(dpy)); + fg = WhitePixel(dpy, DefaultScreen(dpy)); + + /* + * Set the border width of the window, and the gap between the text + * and the edge of the window, "pad". + */ + bw = 0; + + /* + * Deal with providing the window with an initial position & size. + * Fill out the XSizeHints struct to inform the window manager. See + * Sections 9.1.6 & 10.3. + */ + xsh.flags = (PPosition | PSize); + xsh.height = height; + xsh.width = width; + xsh.x = x; + xsh.y = y; /*(DisplayHeight(dpy, DefaultScreen(dpy)) - xsh.height) / 2;*/ + + /* + * Create the Window with the information in the XSizeHints, the + * border width, and the border & background pixels. See Section 3.3. + */ + + /* + DIALOG: + XSetTransientForHint (xdisplay, xid, xparent); + */ + + + win = XCreateSimpleWindow(dpy, + parent?(Window)parent:DefaultRootWindow(dpy), + xsh.x, xsh.y, xsh.width, xsh.height, + bw, bd, bg); + if (!decorate) { + XSetWindowAttributes xattributes; + long xattributes_mask; + + xattributes.save_under = True; + xattributes.override_redirect = True; + xattributes.cursor = None; + xattributes_mask = CWCursor | CWSaveUnder | CWOverrideRedirect; + XChangeWindowAttributes(dpy, win, xattributes_mask, &xattributes); + } + /* + * { + * Atom mwmhints; + * MwmHints hints; + * + * mwmhints = XInternAtom(dpy, _XA_MWM_HINTS, False); + * hints.decorations = 0; + * hints.flags = MWM_HINTS_DECORATIONS; + * XChangeProperty(dpy, win, mwmhints, mwmhints, 32, + * PropModeReplace, (unsigned char *)&hints, 4); + * } + */ + /* attr.background_pixel = bg; + attr.border_pixel = bd; + attr.backing_store = NotUseful; + attr.save_under = 0; + + win = XCreateWindow(dpy, + parent?(Window)parent:DefaultRootWindow(dpy), + xsh.x, xsh.y, xsh.width, xsh.height, + bw, CopyFromParent, CopyFromParent, CopyFromParent,CWBackPixel | CWBorderPixel | CWBackingStore | CWSaveUnder, &attr); + */ + /*printf("Fenetre parente : %d, nouvelle fenetre : %d\n",parent,win);*/ + /* + * Set the standard properties for the window managers. See Section + * 9.1. + */ + /*XSetStandardProperties(dpy, win, STRING, STRING, None, argv, argc, &xsh); + *XSetWMHints(dpy, win, &xwmh); + */ + /* + * Ensure that the window's colormap field points to the default + * colormap, so that the window manager knows the correct colormap to + * use for the window. See Section 3.2.9. Also, set the window's Bit + * Gravity to reduce Expose events. + */ + /* xswa.colormap = DefaultColormap(dpy, DefaultScreen(dpy)); + * xswa.bit_gravity = CenterGravity; + * XChangeWindowAttributes(dpy, win, (CWColormap | CWBitGravity), &xswa); + */ + /* + * Create the GC for writing the text. See Section 5.3. + */ + /* gcv.font = fontstruct->fid; + * gcv.foreground = fg; + * gcv.background = bg; + * gc = XCreateGC(dpy, win, (GCFont | GCForeground | GCBackground), &gcv); + */ + + /* + * Specify the event types we're interested in. See + * Sections 8.5 & 8.4.5.1 + */ + XSelectInput(dpy, win, KeyPressMask|KeyReleaseMask | + ButtonPressMask|ButtonReleaseMask| + EnterWindowMask|LeaveWindowMask| + PointerMotionMask| + Button1MotionMask|Button2MotionMask|Button3MotionMask| + Button4MotionMask|Button5MotionMask|ButtonMotionMask| + KeymapStateMask|ExposureMask|VisibilityChangeMask| + StructureNotifyMask| + /*ResizeRedirectMask|*/ + /*SubstructureNotifyMask|*/ + /*SubstructureRedirectMask|*/ + FocusChangeMask|PropertyChangeMask|ColormapChangeMask + /*|OwnerGrabButtonMask*/ ); + + /*ExposureMask | KeyPressMask | ButtonPressMask + * | EnterWindowMask | LeaveWindowMask | PointerMotionMask + * | KeyPressMask ); + */ + + + if (!parent) { + if (!atom_DELWIN) + atom_DELWIN = XInternAtom (dpy, "WM_DELETE_WINDOW", False); + + /* the following fakes 'XSetWMProtocols(dpy, win, &atom_DELWIN,1);' */ + + if (!atom_PROTOCOLS) + atom_PROTOCOLS = XInternAtom (dpy, "WM_PROTOCOLS", False); + + if (atom_PROTOCOLS) + XChangeProperty(dpy, win, atom_PROTOCOLS, XA_ATOM, 32, + PropModeReplace, (unsigned char *) &atom_DELWIN, 1); + } + + return (void *)win; +#endif +} + +extern void * basic_window_get_drawing_widget(void *window){ +#ifdef WIN32 + /* --TODO: change into macro */ + return hdc; +#else + return window; +#endif +} + +char* basic_window_get_title(void *window){ +#ifdef WIN32 + char *result=NULL; + int size = GetWindowTextLength((HWND)window); + if (size++) { + result = malloc(size); + GetWindowText((HWND)window, result, size); + } + return result; +#else + char *title; + if (!XFetchName(dpy,(Window)window,&title)) + return NULL; + else + return title; +#endif +} + +void basic_window_free_title(void *title){ +#ifdef WIN32 + free(title); +#else + XFree(title); +#endif +} + +void basic_window_set_title(void *window, void *title){ +#ifdef WIN32 + first_free_cmd->cmd_type = SET_TITLE; + first_free_cmd->param1 = (int)window; + first_free_cmd->param2 = (int)title; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); +#else + XStoreName(dpy,(Window)window,(char *)title); +#endif +} + +void basic_window_set_bg_color(void *window, void *color){ +#ifdef WIN32 + /* --TODO: handle pixmap background */ + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + DeleteObject (desc->background); + desc->background = CreateSolidBrush((COLORREF)color); + vision_check(desc->background); +#else + XSetWindowBackground(dpy,(Window)window,(unsigned long)color); +#endif +} + +void basic_window_set_bg_pixmap(void *window, void *pixmap){ +#ifdef WIN32 + /* --TODO: review this function for window 95 pixmap limited to 8x8. */ + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + DeleteObject (desc->background); + desc->background = CreatePatternBrush((HBITMAP)pixmap); + vision_check(desc->background); + +#if 0 + use part of this code in basic_vision for background painting + + RECT rect; + HBRUSH hbr; + HDC hdc_bg; + HBITMAP oldbitmap; + + GetClipBox (hdc, &rect); + /* if (version windows != 95 || (pixmap->width <= 8 && pixmap->height <= 8)) */ + { + /* use brush only with small pixmap with Windows 95 (other version support any size).*/ + hbr = CreatePatternBrush (pixmap); + FillRect (hdc, &rect, hbr); + DeleteObject (hbr); + } + /* else*/ + { + /* use BitBlt */ + int i, j; + hdc_bg = CreateCompatibleDC (hdc); + oldbitmap = SelectObject (hdc_bg, pixmap); + i = 0; + /* while (i < rect.right) + { + j = 0; + while (j < rect.bottom) + { + if (i+pixmap->width >= rect.left && j+pixmap->height >= rect.top) + { + BitBlt (hdc, i, j, pixmap->width, pixmap->height, + bgdc, 0, 0, SRCCOPY); + } + j += pixmap->height; + } + i += pixmap->width; + } + */ + SelectObject (hdc_bg, oldbitmap); + DeleteDC (hdc_bg); + } + +#endif + +#else + XSetWindowBackgroundPixmap(dpy,(Window)window,(Pixmap) pixmap); +#endif +} + +void basic_window_clear_no_expose(void *window) { + /* clear window (restore background) without expose event */ +#ifdef WIN32 + HDC hdc = GetDC((HWND)window); + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + RECT area; + vision_check_call(GetClientRect((HWND)window, &area)); + /* --TODO: handle pixmap case */ + vision_check_call(FillRect(hdc, &area, desc->background)); + vision_check_call(ReleaseDC((HWND)window, hdc)); +#else + XClearWindow(dpy,(Window)window); +#endif +} + +void basic_window_clear_area_no_expose(void *window, int x, int y, int w, int h){ + /* clear area (restore background) without expose event */ +#ifdef WIN32 + HDC hdc = GetDC((HWND)window); + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + RECT area; + area.left = x; + area.top = y; + area.right = x + w; + area.bottom = y + h; + /* --TODO: handle pixmap case */ + vision_check_call(FillRect(hdc, &area, desc->background)); + vision_check_call(ReleaseDC((HWND)window, hdc)); +#else + XClearArea(dpy,(Window)window, x, y, w, h, False); +#endif +} + +void basic_window_clear_area(void *window, int x, int y, int w, int h){ + /* clear window (restore background) and emit expose event on this area */ +#ifdef WIN32 + first_free_cmd->cmd_type = CLEAR_AREA; + first_free_cmd->param1 = (int)window; + first_free_cmd->param2 = x; + first_free_cmd->param3 = y; + first_free_cmd->param4 = x + w; + first_free_cmd->param5 = y + h; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); +#else + XClearArea(dpy,(Window)window, x, y, w, h, True); +#endif +} + +void basic_window_set_kbd_focus(void *window){ + /*--TODO: remove set_kbd_focus? */ +#ifdef WIN32 + first_free_cmd->cmd_type = SET_FOCUS; + first_free_cmd->param1 = (int)window; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); +#else + +#endif +} + +void basic_window_map(void *window) { +#ifdef WIN32 + first_free_cmd->cmd_type = MAP_WINDOW; + first_free_cmd->param1 = (int)window; + first_free_cmd->param2 = main_nCmdShow; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); + /*UpdateWindow((HWND)window);*/ /* --TODO: really needed ? */ + main_nCmdShow = SW_SHOW; +#else + XMapWindow(dpy,(Window)window); +#endif +} + +void basic_window_unmap(void *window) { +#ifdef WIN32 + first_free_cmd->cmd_type = MAP_WINDOW; + first_free_cmd->param1 = (int)window; + first_free_cmd->param2 = SW_HIDE; + if (first_free_cmd->next == first_cmd) { + struct cmd_list *new_cell = malloc(sizeof(struct cmd_list)); + new_cell->next = first_free_cmd->next; + first_free_cmd->next = new_cell; + first_free_cmd = new_cell; /* don't merge with previous line, + * first_free_cmd is the last change done and + * then the consumer may use this cell */ + } else { + first_free_cmd = first_free_cmd->next; + } + vision_check_call(ReleaseSemaphore(sem_cmd_ready, 1, NULL)); +#else + XUnmapWindow(dpy,(Window)window); +#endif +} + +void basic_window_set_geometry(void *window,int x, int y, int w, int h){ +#ifdef WIN32 + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + if (desc->decorated) + move_window((HWND)window, x - decorated_window_x_offset, + y - decorated_window_y_offset, + w + decorated_window_width_offset, + h + decorated_window_height_offset, TRUE); + else + move_window((HWND)window, x, y, w, h, TRUE); +#else + XMoveResizeWindow(dpy, (Window)window, x, y, w, h); +#endif +} + +void basic_window_set_requisition(void *window, int min_w, int min_h, int max_w, int max_h){ +#ifdef WIN32 + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + desc->min_width = min_w + decorated_window_width_offset; + desc->max_width = max_w + decorated_window_width_offset; + desc->min_height = min_h + decorated_window_height_offset; + desc->max_height = max_h + decorated_window_height_offset; +#else + XSizeHints hints; + hints.flags = PMinSize|PMaxSize; + hints.min_width = min_w; + hints.max_width = max_w; + hints.min_height = min_h; + hints.max_height = max_h; + XSetWMNormalHints(dpy, (Window)window, &hints); +#endif +} + +void basic_window_set_position(void *window, int x, int y){ +#ifdef WIN32 + RECT size; + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + vision_check_call(GetClientRect((HWND)window, &size)); + if (desc->decorated) + move_window((HWND)window, x - decorated_window_x_offset, + y - decorated_window_y_offset, + size.right + decorated_window_width_offset, + size.bottom + decorated_window_height_offset, TRUE); + else + move_window((HWND)window, x, y, size.right, size.bottom, TRUE); +#else + XMoveWindow(dpy, (Window)window, x, y); +#endif +} + +void basic_window_set_size(void *window,int x, int y, int width, int height){ +#ifdef WIN32 + window_description *desc = (window_description*)GetWindowLong((HWND)window, GWL_USERDATA); + if (desc->decorated) + move_window((HWND)window, x - decorated_window_x_offset, + y - decorated_window_y_offset, + width + decorated_window_width_offset, + height + decorated_window_height_offset, TRUE); + else + move_window((HWND)window, x, y, width, height, TRUE); +#else + XResizeWindow(dpy, (Window)window, width, height); +#endif +} +unsigned int fsoc_count_ceil=308; +unsigned int rsoc_count_ceil=87; + +/*INTEGER_16*/T2 r10to_integer_32(T10 C){ +T2 R=0; +R=/*IC*/(T2)(C); +return R; +}/*--*/ + +/*INTEGER_16*/T3 r10decimal_digit(T10 C){ +T3 R=0; +R=((T3)(((int16_t)(C))+(INT16_C(48)))); +return R; +}/*--*/ + +/*INTEGER_16*/void r10append_in(T10 C,T0* a1){ +T10 _val=0; +T2 _i=0; +T2 _idx=0; +if((C)==(INT8_C(0))){ +r7extend(((T7*)a1),((T3)'0')); +} +else{ +/*l280c5/integer_general.e*/ +if(((int16_t)(C))>(INT16_C(0))){ +/*l282c7/integer_general.e*/ +_val=C; +/*l284c7/integer_general.e*/ +_i=((int32_t)((/*RF2*/(((T7*)a1))->_count/*3p*/)))+(INT32_C(1)); +} +else{ +/*l286c14/integer_general.e*/ +r7extend(((T7*)a1),((T3)'\055')); +/*l288c7/integer_general.e*/ +_i=((int32_t)((/*RF2*/(((T7*)a1))->_count/*3p*/)))+(INT32_C(1)); +/*l290c7/integer_general.e*/ +_val=((int16_t)(C))%(INT16_C(10)); +/*l291c7/integer_general.e*/ +if(((int16_t)(_val))<=(INT16_C(0))){ +/*l292c15/integer_general.e*/ +r7extend(((T7*)a1),r10decimal_digit(-(_val))); +/*l293c8/integer_general.e*/ +_val=-(((int16_t)(C))/(INT16_C(10))); +} +else{ +/*l295c15/integer_general.e*/ +r7extend(((T7*)a1),r10decimal_digit(((int16_t)(-(_val)))+(INT16_C(10)))); +/*l296c8/integer_general.e*/ +_val=((int16_t)(-(((int16_t)(C))/(INT16_C(10)))))-(INT16_C(1)); +} +} +while (!((_val)==(INT8_C(0)))) +{ +/*l305c13/integer_general.e*/ +r7extend(((T7*)a1),r10decimal_digit(((int16_t)(_val))%(INT16_C(10)))); +/*l306c6/integer_general.e*/ +_val=((int16_t)(_val))/(INT16_C(10)); +} +/*l309c5/integer_general.e*/ +_idx=(/*RF2*/(((T7*)a1))->_count/*3p*/); +while (!(((int32_t)(_i))>=(_idx))) +{ +/*l314c13/integer_general.e*/ +r7swap(((T7*)a1),_i,_idx); +/*l315c6/integer_general.e*/ +_idx=((int32_t)(_idx))-(INT32_C(1)); +/*l316c6/integer_general.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +}/*--*/ +T9 oBC101sprintf_buffer=(void*)0; + +/*REAL_64*/void r5append_in_format(T5 C,T0* a1,T2 a2){ +T2 _i=0; +/*l189c5/real_general.e*/ +sprintf_real_64(oBC101sprintf_buffer,((T3)'f'),a2,C); +/*l190c5/real_general.e*/ +_i=INT32_C(0); +while (!(((oBC101sprintf_buffer)[_i])==(((T3)'\000')))) +{ +/*l194c9/real_general.e*/ +r7extend(((T7*)a1),(oBC101sprintf_buffer)[_i]); +/*l195c5/real_general.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*POINTER*/T2 r8hash_code(T8 C){ +T2 R=0; +R=pointer_hash_code(C); +return R; +}/*--*/ + +/*INTEGER_32*/T6 r2in_range(T2 C,T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(C))>=(a1))&&((T6)(((int32_t)(C))<=(a2)))))); +return R; +}/*--*/ + +/*INTEGER_32*/T2 r2max(T2 C,T2 a1){ +T2 R=0; +if(((int32_t)(C))>=(a1)){ +R=C; +} +else{ +R=a1; +} +return R; +}/*--*/ + +/*INTEGER_32*/T3 r2decimal_digit(T2 C){ +T3 R=0; +R=((T3)(((int32_t)(C))+(INT32_C(48)))); +return R; +}/*--*/ + +/*INTEGER_32*/void r2append_in(T2 C,T0* a1){ +T2 _val=0; +T2 _i=0; +T2 _idx=0; +if((C)==(INT8_C(0))){ +r7extend(((T7*)a1),((T3)'0')); +} +else{ +/*l280c5/integer_general.e*/ +if(((int32_t)(C))>(INT32_C(0))){ +/*l282c7/integer_general.e*/ +_val=C; +/*l284c7/integer_general.e*/ +_i=((int32_t)((/*RF2*/(((T7*)a1))->_count/*3p*/)))+(INT32_C(1)); +} +else{ +/*l286c14/integer_general.e*/ +r7extend(((T7*)a1),((T3)'\055')); +/*l288c7/integer_general.e*/ +_i=((int32_t)((/*RF2*/(((T7*)a1))->_count/*3p*/)))+(INT32_C(1)); +/*l290c7/integer_general.e*/ +_val=((int32_t)(C))%(INT32_C(10)); +/*l291c7/integer_general.e*/ +if(((int32_t)(_val))<=(INT32_C(0))){ +/*l292c15/integer_general.e*/ +r7extend(((T7*)a1),r2decimal_digit(-(_val))); +/*l293c8/integer_general.e*/ +_val=-(((int32_t)(C))/(INT32_C(10))); +} +else{ +/*l295c15/integer_general.e*/ +r7extend(((T7*)a1),r2decimal_digit(((int32_t)(-(_val)))+(INT32_C(10)))); +/*l296c8/integer_general.e*/ +_val=((int32_t)(-(((int32_t)(C))/(INT32_C(10)))))-(INT32_C(1)); +} +} +while (!((_val)==(INT8_C(0)))) +{ +/*l305c13/integer_general.e*/ +r7extend(((T7*)a1),r2decimal_digit(((int32_t)(_val))%(INT32_C(10)))); +/*l306c6/integer_general.e*/ +_val=((int32_t)(_val))/(INT32_C(10)); +} +/*l309c5/integer_general.e*/ +_idx=(/*RF2*/(((T7*)a1))->_count/*3p*/); +while (!(((int32_t)(_i))>=(_idx))) +{ +/*l314c13/integer_general.e*/ +r7swap(((T7*)a1),_i,_idx); +/*l315c6/integer_general.e*/ +_idx=((int32_t)(_idx))-(INT32_C(1)); +/*l316c6/integer_general.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +}/*--*/ + +/*INTEGER_32*/T10 r2high_16(T2 C){ +T10 R=0; +R=((int16_t)(((C)>>(INT8_C(16))))); +return R; +}/*--*/ + +/*CHARACTER*/T6 r3_ix_6261(T3 C,T3 a1){ +T6 R=0; +R=((T6)(((int16_t)(T3code(C)))>=(T3code(a1)))); +return R; +}/*--*/ + +/*CHARACTER*/T6 r3_ix_6061(T3 C,T3 a1){ +T6 R=0; +R=((T6)(((int16_t)(T3code(C)))<=(T3code(a1)))); +return R; +}/*--*/ + +/*CHARACTER*/T6 r3is_digit(T3 C){ +T6 R=0; +R=((T6)((T6)(((((unsigned)(C))>=((unsigned)(((T3)'0')))))&&((T6)((((unsigned)(C))<=((unsigned)(((T3)'9'))))))))); +return R; +}/*--*/ + +/*CHARACTER*/T1 r3value(T3 C){ +T1 R=0; +R=((int8_t)(((int8_t)(T3code(C)))))-(INT8_C(48)); +return R; +}/*--*/ + +/*CHARACTER*/T6 r3is_separator(T3 C){ +T6 R=0; +/*[INSPECT*/ +{int inspect_tmp_1=C; +switch(inspect_tmp_1){ +case 0: +case 9: +case 10: +case 12: +case 13: +case 32: +R=((T6)(1)); +break; +} +}/*INSPECT]*/ +return R; +}/*--*/ + +/*CHARACTER*/T1 r3decimal_value(T3 C){ +T1 R=0; +R=((int8_t)(((int8_t)(T3code(C)))))-(INT8_C(48)); +return R; +}/*--*/ + +/*BOOLEAN*/T6 r6_ix_or(T6 C,T6 a1){ +T6 R=0; +R=((T6)((T6)((C)||((T6)(a1))))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r290clear_all(T290 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/T290 r290realloc(T290 C,T2 a1,T2 a2){ +T290 R=(void*)0; +/*l68c4/native_array.e*/ +R=new290(a2); +/*l69c11/native_array.e*/ +r290copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r290copy_from(T290 C,T290 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]*/void r289clear_all(T289 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[JOB]*/void r288clear_all(T288 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[JOB]*/void r288remove(T288 C,T2 a1,T2 a2){ +T2 _i=0; +_i=a1; +while (!((_i)==(a2))) +{ +/*l406c5/native_array.e*/ +(C)[_i]=((C)[((int32_t)(_i))+(INT32_C(1))]); +/*l407c5/native_array.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[JOB]*/T288 r288realloc(T288 C,T2 a1,T2 a2){ +T288 R=(void*)0; +/*l68c4/native_array.e*/ +R=new288(a2); +/*l69c11/native_array.e*/ +r288copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[JOB]*/void r288copy_from(T288 C,T288 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[EVENT_CATCHER]*/void r287clear_all(T287 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]*/void r284clear_all(T284 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r281clear_all(T281 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]*/void r276clear_all(T276 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]*/void r270clear_all(T270 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]*/void r267clear_all(T267 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]*/void r263clear_all(T263 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[TOPLEVEL_WINDOW]*/void r262clear_all(T262 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[KEY_RANGE]*/void r261clear_all(T261 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[KEY_RANGE]*/T261 r261realloc(T261 C,T2 a1,T2 a2){ +T261 R=(void*)0; +/*l68c4/native_array.e*/ +R=new261(a2); +/*l69c11/native_array.e*/ +r261copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[KEY_RANGE]*/void r261copy_from(T261 C,T261 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[BUTTON_RANGE]*/void r260clear_all(T260 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[BUTTON_RANGE]*/T260 r260realloc(T260 C,T2 a1,T2 a2){ +T260 R=(void*)0; +/*l68c4/native_array.e*/ +R=new260(a2); +/*l69c11/native_array.e*/ +r260copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[BUTTON_RANGE]*/void r260copy_from(T260 C,T260 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[AXES_RANGE]*/void r259clear_all(T259 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[AXES_RANGE]*/T259 r259realloc(T259 C,T2 a1,T2 a2){ +T259 R=(void*)0; +/*l68c4/native_array.e*/ +R=new259(a2); +/*l69c11/native_array.e*/ +r259copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[AXES_RANGE]*/void r259copy_from(T259 C,T259 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]*/void r257clear_all(T257 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r255clear_all(T255 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]*/void r251clear_all(T251 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[INTEGER_32]*/void r250set_slice_with(T250 C,T2 a1,T2 a2,T2 a3){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))>(a3))) +{ +/*l542c5/native_array.e*/ +(C)[_i]=(a1); +/*l543c5/native_array.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[INTEGER_32]*/void r250clear_all(T250 C,T2 a1){ +T2 _v=0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[INTEGER_32]*/void r250set_all_with(T250 C,T2 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l524c5/native_array.e*/ +(C)[_i]=(a1); +/*l525c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[INTEGER_32]*/T250 r250realloc(T250 C,T2 a1,T2 a2){ +T250 R=(void*)0; +/*l68c4/native_array.e*/ +R=new250(a2); +/*l69c11/native_array.e*/ +r250copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[INTEGER_32]*/void r250copy_from(T250 C,T250 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[POINTER,STRING]]*/void r247clear_all(T247 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]*/void r239clear_all(T239 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238clear_all(T238 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238clear(T238 C,T2 a1,T2 a2){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))>(a2))) +{ +/*l579c5/native_array.e*/ +(C)[_i]=(_v); +/*l580c5/native_array.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238remove(T238 C,T2 a1,T2 a2){ +T2 _i=0; +_i=a1; +while (!((_i)==(a2))) +{ +/*l406c5/native_array.e*/ +(C)[_i]=((C)[((int32_t)(_i))+(INT32_C(1))]); +/*l407c5/native_array.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/T238 r238realloc(T238 C,T2 a1,T2 a2){ +T238 R=(void*)0; +/*l68c4/native_array.e*/ +R=new238(a2); +/*l69c11/native_array.e*/ +r238copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238copy_from(T238 C,T238 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[IVY_CLIENT]*/T2 r238fast_index_of(T238 C,T0* a1,T2 a2,T2 a3){ +T2 R=0; +R=a2; +while (!((T6)((((int32_t)(R))>(a3))||((T6)((a1)==((void*)((C)[R]))))))) +{ +R=((int32_t)(R))+(INT32_C(1)); +} +return R; +}/*--*/ + +/*NATIVE_ARRAY[LOOP_ITEM]*/void r237clear_all(T237 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[LOOP_ITEM]*/T237 r237realloc(T237 C,T2 a1,T2 a2){ +T237 R=(void*)0; +/*l68c4/native_array.e*/ +R=new237(a2); +/*l69c11/native_array.e*/ +r237copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[LOOP_ITEM]*/void r237copy_from(T237 C,T237 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[X_INPUT_DEVICE]*/void r220clear_all(T220 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[STRING]*/void r219clear_all(T219 C,T2 a1){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[STRING]*/void r219clear(T219 C,T2 a1,T2 a2){ +T0* _v=(void*)0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))>(a2))) +{ +/*l579c5/native_array.e*/ +(C)[_i]=(_v); +/*l580c5/native_array.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[STRING]*/T219 r219realloc(T219 C,T2 a1,T2 a2){ +T219 R=(void*)0; +/*l68c4/native_array.e*/ +R=new219(a2); +/*l69c11/native_array.e*/ +r219copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[STRING]*/void r219copy_from(T219 C,T219 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/void r9clear_all(T9 C,T2 a1){ +T3 _v=0; +T2 _i=0; +_i=a1; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l559c5/native_array.e*/ +(C)[_i]=(_v); +/*l560c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/T9 r9realloc(T9 C,T2 a1,T2 a2){ +T9 R=(void*)0; +/*l68c4/native_array.e*/ +R=new9(a2); +/*l69c11/native_array.e*/ +r9copy_from(R,C,((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/void r9copy_from(T9 C,T9 a1,T2 a2){ +T2 _i=0; +_i=a2; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l596c5/native_array.e*/ +(C)[_i]=((a1)[_i]); +/*l597c5/native_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/T2 r9fast_index_of(T9 C,T3 a1,T2 a2,T2 a3){ +T2 R=0; +R=a2; +while (!((T6)((((int32_t)(R))>(a3))||((T6)((a1)==((C)[R])))))) +{ +R=((int32_t)(R))+(INT32_C(1)); +} +return R; +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/void r9copy_at(T9 C,T2 a1,T9 a2,T2 a3){ +T2 _at_idx=0; +T2 _src_idx=0; +/*l464c5/native_array.e*/ +_src_idx=((int32_t)(a3))-(INT32_C(1)); +/*l465c5/native_array.e*/ +_at_idx=((int32_t)(a1))+(_src_idx); +while (!(((int32_t)(_src_idx))<(INT32_C(0)))) +{ +/*l469c5/native_array.e*/ +(C)[_at_idx]=((a2)[_src_idx]); +/*l470c5/native_array.e*/ +_src_idx=((int32_t)(_src_idx))-(INT32_C(1)); +/*l471c5/native_array.e*/ +_at_idx=((int32_t)(_at_idx))-(INT32_C(1)); +} +}/*--*/ + +/*NATIVE_ARRAY[CHARACTER]*/T6 r9fast_memcmp(T9 C,T9 a1,T2 a2){ +T6 R=0; +T2 _i=0; +/*l124c4/native_array.e*/ +_i=((int32_t)(a2))-(INT32_C(1)); +while (!((T6)((((int32_t)(_i))<(INT32_C(0)))||((T6)(((C)[_i])!=((a1)[_i])))))) +{ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l131c4/native_array.e*/ +R=((T6)(((int32_t)(_i))<(INT32_C(0)))); +return R; +}/*--*/ + +T7*create7from_external(T8 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +tmp0=((T0*)(new7())); +r7from_external(((T7*)tmp0),a1); +return ((T7*)tmp0); +}/*--*/ + +/*STRING*/void r7put(T7* C,T3 a1,T2 a2){ +((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(a2))-(INT32_C(1))]=(a1); +}/*--*/ + +/*STRING*/void r7remove_between(T7* C,T2 a1,T2 a2){ +T2 _i=0; +T2 _len=0; +/*l1606c4/string.e*/ +_len=((int32_t)(((int32_t)(a2))-(a1)))+(INT32_C(1)); +/*l1607c4/string.e*/ +if(((int32_t)(_len))>(INT32_C(0))){ +/*l1608c5/string.e*/ +_i=((int32_t)(a2))+(INT32_C(1)); +while (!(((int32_t)(_i))>((/*RF2*/(C)->_count/*3p*/)))) +{ +/*l1613c6/string.e*/ +r7put(C,((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))],((int32_t)(_i))-(_len)); +/*l1614c6/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l1616c5/string.e*/ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(_len); +} +}/*--*/ + +/*STRING*/T6 r7is_equal(T7* C,T0* a1){ +T6 R=0; +R=((T6)((T6)((((/*RF2*/(C)->_count/*3p*/))==((/*RF2*/(((T7*)a1))->_count/*3p*/)))&&((T6)(r9fast_memcmp((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(((T7*)a1))->_storage/*3p*/),(/*RF2*/(C)->_count/*3p*/))))))); +return R; +}/*--*/ + +/*STRING*/void r7append(T7* C,T0* a1){ +T2 _s_count=0; +T2 _needed_capacity=0; +/*l1211c4/string.e*/ +_s_count=(/*RF2*/(((T7*)a1))->_count/*3p*/); +/*l1212c4/string.e*/ +_needed_capacity=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(_s_count); +/*l1213c4/string.e*/ +if(((int32_t)(_needed_capacity))>((/*RF2*/(C)->_capacity/*3p*/))){ +r7ensure_capacity(C,_needed_capacity); +} +/*l1216c12/string.e*/ +r9copy_at((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_count/*3p*/),(/*RF2*/(((T7*)a1))->_storage/*3p*/),_s_count); +/*l1217c4/string.e*/ +/*SFN*/(C->_count/*3p*/)=_needed_capacity; +}/*--*/ + +/*STRING*/void r7copy(T7* C,T0* a1){ +T2 _c=0; +/*l1151c4/string.e*/ +_c=(/*RF2*/(((T7*)a1))->_count/*3p*/); +/*l1152c4/string.e*/ +if(((int32_t)(_c))>(INT32_C(0))){ +/*l1153c5/string.e*/ +if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))<(_c)){ +/*l1154c6/string.e*/ +/*SFN*/(C->_storage/*3p*/)=new9(_c); +/*l1155c6/string.e*/ +/*SFN*/(C->_capacity/*3p*/)=_c; +} +/*l1157c13/string.e*/ +r9copy_from((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(((T7*)a1))->_storage/*3p*/),((int32_t)(_c))-(INT32_C(1))); +} +/*l1159c4/string.e*/ +/*SFN*/(C->_count/*3p*/)=_c; +}/*--*/ + +/*STRING*/T6 r7is_real(T7* C){ +T6 R=0; +T2 _i=0; +T2 _state=0; +T3 _cc=0; +T5 _base=0; +T5 _exp=0; +T5 _value=0; +T5 _multiplier=0; +T6 _negative=0; +T6 _neg_exp=0; +/*l758c4/string.e*/ +_i=INT32_C(1); +while (!((T6)(((_state)==(INT8_C(9)))||((T6)(((int32_t)(_i))>((/*RF2*/(C)->_count/*3p*/))))))) +{ +/*l765c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l766c5/string.e*/ +/*[INSPECT*/ +{int inspect_tmp_1=_state; +switch(inspect_tmp_1){ +case 0: +if(r3is_separator(_cc)){ +} +else if((_cc)==(((T3)'\053'))){ +_state=INT32_C(1); +} +else if((_cc)==(((T3)'\055'))){ +/*l773c7/string.e*/ +_negative=((T6)(1)); +/*l774c7/string.e*/ +_state=INT32_C(1); +} +else if(r3is_digit(_cc)){ +/*l776c7/string.e*/ +_base=/*IC*/(T5)(r3decimal_value(_cc)); +/*l777c7/string.e*/ +_state=INT32_C(2); +} +else if((_cc)==(((T3)'\056'))){ +_state=INT32_C(3); +} +else{ +_state=INT32_C(9); +} +break; +case 1: +if(r3is_digit(_cc)){ +/*l785c7/string.e*/ +_base=/*IC*/(T5)(r3decimal_value(_cc)); +/*l786c7/string.e*/ +_state=INT32_C(2); +} +else if((_cc)==(((T3)'\056'))){ +_state=INT32_C(3); +} +else{ +_state=INT32_C(9); +} +break; +case 2: +if(r3is_digit(_cc)){ +_base=((_base)*(/*IC*/(T5)(INT8_C(10))))+(/*IC*/(T5)(r3decimal_value(_cc))); +} +else if((_cc)==(((T3)'\056'))){ +_state=INT32_C(3); +} +else if((T6)(((_cc)==(((T3)'e')))||((T6)((_cc)==(((T3)'E')))))){ +_state=INT32_C(5); +} +else if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else{ +_state=INT32_C(9); +} +break; +case 3: +/*l805c6/string.e*/ +_multiplier=/*0.1*/1e-1; +/*l806c6/string.e*/ +if(r3is_digit(_cc)){ +/*l807c7/string.e*/ +_base=(_base)+((_multiplier)*(/*IC*/(T5)(r3decimal_value(_cc)))); +/*l808c7/string.e*/ +_state=INT32_C(4); +} +else{ +_state=INT32_C(9); +} +break; +case 4: +/*l813c6/string.e*/ +_multiplier=(_multiplier)*(/*0.1*/1e-1); +/*l814c6/string.e*/ +if(r3is_digit(_cc)){ +_base=(_base)+((_multiplier)*(/*IC*/(T5)(r3decimal_value(_cc)))); +} +else if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else if((T6)(((_cc)==(((T3)'e')))||((T6)((_cc)==(((T3)'E')))))){ +_state=INT32_C(5); +} +else{ +_state=INT32_C(9); +} +break; +case 5: +if((_cc)==(((T3)'\055'))){ +/*l825c7/string.e*/ +_neg_exp=((T6)(1)); +/*l826c7/string.e*/ +_state=INT32_C(6); +} +else if((_cc)==(((T3)'\053'))){ +_state=INT32_C(6); +} +else if(r3is_digit(_cc)){ +/*l830c7/string.e*/ +_exp=/*IC*/(T5)(r3decimal_value(_cc)); +/*l831c7/string.e*/ +_state=INT32_C(7); +} +else{ +_state=INT32_C(9); +} +break; +case 6: +if(r3is_digit(_cc)){ +/*l837c7/string.e*/ +_exp=/*IC*/(T5)(r3decimal_value(_cc)); +/*l838c7/string.e*/ +_state=INT32_C(7); +} +else{ +_state=INT32_C(9); +} +break; +case 7: +if(r3is_digit(_cc)){ +_exp=((_exp)*(/*IC*/(T5)(INT8_C(10))))+(/*IC*/(T5)(r3decimal_value(_cc))); +} +else if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else{ +_state=INT32_C(9); +} +break; +default:; +if(r3is_separator(_cc)){ +} +else{ +_state=INT32_C(9); +} +} +}/*INSPECT]*/ +/*l856c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l858c4/string.e*/ +if((T6)(((T6)(((_state)!=(INT8_C(0)))&&((T6)((_state)!=(INT8_C(9))))))&&((T6)((_state)!=(INT8_C(1)))))){ +/*l859c5/string.e*/ +R=((T6)(1)); +/*l860c5/string.e*/ +if(_neg_exp){ +_exp=(/*IC*/(T5)(INT8_C(-1)))*(_exp); +} +/*l863c5/string.e*/ +_value=(_base)*(pow(/*10.0*/1e1,_exp)); +/*l864c5/string.e*/ +if((_value)>(EIF_MAXIMUM_REAL)){ +R=((T6)(0)); +} +} +return R; +}/*--*/ + +/*STRING*/T2 r7index_of(T7* C,T3 a1,T2 a2){ +T2 R=0; +if(((int32_t)(a2))<=((/*RF2*/(C)->_count/*3p*/))){ +/*l260c5/string.e*/ +R=r9fast_index_of((/*RF2*/(C)->_storage/*3p*/),a1,((int32_t)(a2))-(INT32_C(1)),((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(INT32_C(1))); +/*l261c5/string.e*/ +if((R)==((/*RF2*/(C)->_count/*3p*/))){ +R=INT32_C(0); +} +else{ +R=((int32_t)(R))+(INT32_C(1)); +} +} +return R; +}/*--*/ + +/*STRING*/T6 r7is_integer(T7* C){ +T6 R=0; +T2 _i=0; +T2 _state=0; +T2 _value=0; +T2 _bound=0; +T2 _critical_bound=0; +T3 _cc=0; +/*l439c4/string.e*/ +_i=INT32_C(1); +while (!((T6)(((_state)==(INT8_C(2)))||((T6)(((int32_t)(_i))>((/*RF2*/(C)->_count/*3p*/))))))) +{ +/*l446c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l447c5/string.e*/ +/*[INSPECT*/ +{int inspect_tmp_1=_state; +switch(inspect_tmp_1){ +case 0: +if(r3is_separator(_cc)){ +} +else if((_cc)==(((T3)'\053'))){ +/*l452c7/string.e*/ +_bound=INT32_C(7); +/*l453c7/string.e*/ +_critical_bound=INT32_C(214748364); +/*l454c7/string.e*/ +_state=INT32_C(1); +} +else if((_cc)==(((T3)'\055'))){ +/*l456c7/string.e*/ +_bound=INT32_C(8); +/*l457c7/string.e*/ +_critical_bound=INT32_C(214748364); +/*l458c7/string.e*/ +_state=INT32_C(1); +} +else if(r3is_digit(_cc)){ +/*l460c7/string.e*/ +_bound=INT32_C(7); +/*l461c7/string.e*/ +_critical_bound=INT32_C(214748364); +/*l462c7/string.e*/ +_value=/*IC*/(T2)(r3decimal_value(_cc)); +/*l463c7/string.e*/ +_state=INT32_C(3); +} +else{ +_state=INT32_C(2); +} +break; +case 1: +if(r3is_digit(_cc)){ +/*l469c7/string.e*/ +_value=/*IC*/(T2)(r3decimal_value(_cc)); +/*l470c7/string.e*/ +_state=INT32_C(3); +} +else{ +_state=INT32_C(2); +} +break; +case 3: +if(r3is_digit(_cc)){ +/*l476c7/string.e*/ +_value=((int32_t)(((int32_t)(INT32_C(10)))*(_value)))+(/*IC*/(T2)(r3decimal_value(_cc))); +/*l477c7/string.e*/ +if(((int32_t)(_value))>=(_critical_bound)){ +_state=INT32_C(4); +} +} +else if(r3is_separator(_cc)){ +_state=INT32_C(5); +} +else{ +_state=INT32_C(2); +} +break; +case 4: +if(r3is_digit(_cc)){ +if(((int32_t)(_value))>(_critical_bound)){ +_state=INT32_C(2); +} +else{ +if(((int32_t)(/*IC*/(T2)(r3decimal_value(_cc))))<=(_bound)){ +_state=INT32_C(5); +} +else{ +_state=INT32_C(2); +} +} +} +else if(r3is_separator(_cc)){ +_state=INT32_C(5); +} +else{ +_state=INT32_C(2); +} +break; +default:; +if(r3is_separator(_cc)){ +} +else{ +_state=INT32_C(2); +} +} +}/*INSPECT]*/ +/*l507c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l509c4/string.e*/ +R=((T6)(((int32_t)(_state))>=(INT32_C(3)))); +return R; +}/*--*/ + +/*STRING*/void r7remove_tail(T7* C,T2 a1){ +if(((int32_t)(a1))>((/*RF2*/(C)->_count/*3p*/))){ +/*SFN*/(C->_count/*3p*/)=INT32_C(0); +} +else{ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(a1); +} +}/*--*/ + +/*STRING*/T0* r7twin(T7* C){ +T0* R=(void*)0; +R=(void*)new7(); +r7copy(((T7*)R),((T0*)C)); +return R; +}/*--*/ + +/*STRING*/void r7extend(T7* C,T3 a1){ +/*l1434c4/string.e*/ +if(((/*RF2*/(C)->_count/*3p*/))==((/*RF2*/(C)->_capacity/*3p*/))){ +r7ensure_capacity(C,((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1))); +} +/*l1437c12/string.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_count/*3p*/)]=(a1); +/*l1438c4/string.e*/ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1)); +}/*--*/ + +/*STRING*/T2 r7hash_code(T7* C){ +T2 R=0; +T2 _i=0; +T2 _j=0; +/*l136c4/string.e*/ +/*l137c5/string.e*/ +_j=(/*RF2*/(C)->_count/*3p*/); +/*l138c5/string.e*/ +_i=INT32_C(1); +while (!(((int32_t)(_j))<=(INT32_C(0)))) +{ +/*l142c5/string.e*/ +R=(int32_t)(((uint32_t)((int32_t)(((uint32_t)(/*{INTEGER_32 5}*/INT32_C(5)))*((uint32_t)(R)))))+((uint32_t)(/*IC*/(T2)(T3code(((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]))))); +/*l143c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +/*l144c5/string.e*/ +_j=((int32_t)(_j))-(INT32_C(1)); +} +/*l146c4/string.e*/ +if(((int32_t)(R))<(INT32_C(0))){ +R=~(R); +} +return R; +}/*--*/ + +/*STRING*/void r7remove_last(T7* C){ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(INT32_C(1)); +}/*--*/ + +/*STRING*/void r7add_last(T7* C,T3 a1){ +/*l1434c4/string.e*/ +if(((/*RF2*/(C)->_count/*3p*/))==((/*RF2*/(C)->_capacity/*3p*/))){ +r7ensure_capacity(C,((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1))); +} +/*l1437c12/string.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_count/*3p*/)]=(a1); +/*l1438c4/string.e*/ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1)); +}/*--*/ + +/*STRING*/void r7ensure_capacity(T7* C,T2 a1){ +T2 _new_capacity=0; +if(((NULL!=((void*)((/*RF2*/(C)->_storage/*3p*/)))))==(0)){ +/*l2202c5/string.e*/ +_new_capacity=r2max(a1,INT32_C(32)); +/*l2203c5/string.e*/ +/*SFN*/(C->_storage/*3p*/)=new9(_new_capacity); +/*l2204c5/string.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))<(a1)){ +/*l2206c5/string.e*/ +_new_capacity=r2max(a1,(int32_t)(((uint32_t)((/*RF2*/(C)->_capacity/*3p*/)))*((uint32_t)(INT32_C(2))))); +/*l2207c5/string.e*/ +/*SFN*/(C->_storage/*3p*/)=r9realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l2208c5/string.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +} +}/*--*/ + +/*STRING*/void r7from_external_copy(T7* C,T8 a1){ +T9 _s=(void*)0; +T2 _i=0; +/*l2094c5/string.e*/ +_s=a1; +/*l2095c5/string.e*/ +/*SFN*/(C->_count/*3p*/)=INT32_C(0); +while (!(((_s)[_i])==(((T3)'\000')))) +{ +/*l2099c5/string.e*/ +r7add_last(C,(_s)[_i]); +/*l2100c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*STRING*/void r7from_external(T7* C,T8 a1){ +/*l2068c4/string.e*/ +/*l2069c5/string.e*/ +/*SFN*/(C->_storage/*3p*/)=a1; +/*l2070c5/string.e*/ +/*SFN*/(C->_count/*3p*/)=INT32_C(0); +while (!((((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_count/*3p*/)])==(((T3)'\000')))) +{ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1)); +} +/*l2076c4/string.e*/ +/*SFN*/(C->_capacity/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1)); +}/*--*/ + +/*STRING*/T8 r7to_external(T7* C){ +T8 R=(void*)0; +/*l2043c4/string.e*/ +if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>((/*RF2*/(C)->_count/*3p*/))){ +/*l2044c5/string.e*/ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))+(INT32_C(1)); +/*l2045c5/string.e*/ +if((((/*RF2*/(C)->_storage/*3p*/))[((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(INT32_C(1))])!=(((T3)'\000'))){ +r7put(C,((T3)'\000'),(/*RF2*/(C)->_count/*3p*/)); +} +} +else{ +r7add_last(C,((T3)'\000')); +} +/*l2051c4/string.e*/ +/*SFN*/(C->_count/*3p*/)=((int32_t)((/*RF2*/(C)->_count/*3p*/)))-(INT32_C(1)); +/*l2052c4/string.e*/ +R=((void*)((/*RF2*/(C)->_storage/*3p*/))); +return R; +}/*--*/ + +/*STRING*/T2 r7to_integer(T7* C){ +T2 R=0; +T2 _i=0; +T3 _cc=0; +T6 _negative=0; +/*l519c4/string.e*/ +_i=INT32_C(1); +while (!((r3is_separator(((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]))==(0))) +{ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l528c4/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l529c4/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +/*l530c4/string.e*/ +if((_cc)==(((T3)'\053'))){ +/*l531c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l532c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +else if((_cc)==(((T3)'\055'))){ +/*l534c5/string.e*/ +_negative=((T6)(1)); +/*l535c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l536c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l541c4/string.e*/ +R=/*IC*/(T2)(-(r3value(_cc))); +/*l542c4/string.e*/ +while (!(((int32_t)(_i))>((/*RF2*/(C)->_count/*3p*/)))) +{ +/*l548c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l549c5/string.e*/ +if(r3is_digit(_cc)){ +R=((int32_t)(((int32_t)(INT32_C(10)))*(R)))-(/*IC*/(T2)(r3decimal_value(_cc))); +} +else{ +_i=(/*RF2*/(C)->_count/*3p*/); +} +/*l557c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l559c4/string.e*/ +if(_negative){ +} +else{ +R=-(R); +} +return R; +}/*--*/ + +/*STRING*/void r7remove_head(T7* C,T2 a1){ +if(((int32_t)(a1))>((/*RF2*/(C)->_count/*3p*/))){ +/*SFN*/(C->_count/*3p*/)=INT32_C(0); +} +else{ +if(((int32_t)(a1))>(INT32_C(0))){ +r7remove_between(C,INT32_C(1),a1); +} +} +}/*--*/ + +/*STRING*/void r7swap(T7* C,T2 a1,T2 a2){ +T3 _tmp=0; +/*l1345c4/string.e*/ +_tmp=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(a1))-(INT32_C(1))]; +/*l1346c4/string.e*/ +r7put(C,((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(a2))-(INT32_C(1))],a1); +/*l1347c4/string.e*/ +r7put(C,_tmp,a2); +}/*--*/ + +/*STRING*/T2 r7first_index_of(T7* C,T3 a1){ +T2 R=0; +R=r7index_of(C,a1,INT32_C(1)); +return R; +}/*--*/ + +/*STRING*/T5 r7to_real(T7* C){ +T5 R=0; +T2 _i=0; +T2 _state=0; +T3 _cc=0; +T5 _base=0; +T5 _exp=0; +T5 _multiplier=0; +T6 _negative=0; +T6 _neg_exp=0; +/*l889c4/string.e*/ +_i=INT32_C(1); +while (!(((int32_t)(_i))>((/*RF2*/(C)->_count/*3p*/)))) +{ +/*l896c5/string.e*/ +_cc=((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]; +/*l897c5/string.e*/ +/*[INSPECT*/ +{int inspect_tmp_1=_state; +switch(inspect_tmp_1){ +case 0: +if(r3is_separator(_cc)){ +} +else if((_cc)==(((T3)'\053'))){ +_state=INT32_C(1); +} +else if((_cc)==(((T3)'\055'))){ +/*l904c7/string.e*/ +_negative=((T6)(1)); +/*l905c7/string.e*/ +_state=INT32_C(1); +} +else if(r3is_digit(_cc)){ +/*l907c7/string.e*/ +_base=/*IC*/(T5)(r3decimal_value(_cc)); +/*l908c7/string.e*/ +_state=INT32_C(2); +} +else{ +_state=INT32_C(3); +} +break; +case 1: +if(r3is_digit(_cc)){ +/*l915c7/string.e*/ +_base=/*IC*/(T5)(r3decimal_value(_cc)); +/*l916c7/string.e*/ +_state=INT32_C(2); +} +else{ +_state=INT32_C(3); +} +break; +case 2: +if(r3is_digit(_cc)){ +_base=((_base)*(/*IC*/(T5)(INT8_C(10))))+(/*IC*/(T5)(r3decimal_value(_cc))); +} +else if((_cc)==(((T3)'\056'))){ +_state=INT32_C(3); +} +else if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else{ +_state=INT32_C(5); +} +break; +case 3: +/*l933c6/string.e*/ +_multiplier=/*0.1*/1e-1; +/*l934c6/string.e*/ +if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else{ +/*l938c7/string.e*/ +_base=(_base)+((_multiplier)*(/*IC*/(T5)(r3decimal_value(_cc)))); +/*l939c7/string.e*/ +_state=INT32_C(4); +} +break; +case 4: +/*l942c6/string.e*/ +_multiplier=(_multiplier)*(/*0.1*/1e-1); +/*l943c6/string.e*/ +if(r3is_digit(_cc)){ +_base=(_base)+((_multiplier)*(/*IC*/(T5)(r3decimal_value(_cc)))); +} +else if(r3is_separator(_cc)){ +_state=INT32_C(8); +} +else{ +_state=INT32_C(5); +} +break; +case 5: +if((_cc)==(((T3)'\055'))){ +/*l953c7/string.e*/ +_neg_exp=((T6)(1)); +/*l954c7/string.e*/ +_state=INT32_C(6); +} +else if((_cc)==(((T3)'\053'))){ +_state=INT32_C(6); +} +else{ +/*l959c7/string.e*/ +_exp=/*IC*/(T5)(r3decimal_value(_cc)); +/*l960c7/string.e*/ +_state=INT32_C(7); +} +break; +case 6: +/*l964c6/string.e*/ +_exp=/*IC*/(T5)(r3decimal_value(_cc)); +/*l965c6/string.e*/ +_state=INT32_C(7); +break; +case 7: +if(r3is_digit(_cc)){ +_exp=((_exp)*(/*IC*/(T5)(INT8_C(10))))+(/*IC*/(T5)(r3decimal_value(_cc))); +} +else{ +_state=INT32_C(8); +} +break; +default:; +_i=(/*RF2*/(C)->_count/*3p*/); +} +}/*INSPECT]*/ +/*l977c5/string.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l979c4/string.e*/ +if(_neg_exp){ +_exp=(/*IC*/(T5)(INT8_C(-1)))*(_exp); +} +/*l982c4/string.e*/ +if(_negative){ +R=((/*IC*/(T5)(INT8_C(-1)))*(_base))*(pow(/*10.0*/1e1,_exp)); +} +else{ +R=(_base)*(pow(/*10.0*/1e1,_exp)); +} +return R; +}/*--*/ + +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254make(T254* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new290(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r290clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254add_last(T254* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new290(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r290realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254mark_native_arrays(T254* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark202((T202*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236remove(T236* C,T2 a1){ +/*l343c12/fast_array.e*/ +r288remove((/*RF2*/(C)->_storage/*3p*/),a1,(/*RF2*/(C)->_upper/*3p*/)); +/*l344c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236make(T236* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new288(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r288clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236add_last(T236* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new288(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r288realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[JOB]*/T6 r236is_empty(T236* C){ +T6 R=0; +R=((T6)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))<(INT32_C(0)))); +return R; +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236mark_native_arrays(T236* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)Xgc_mark71((T0*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236add(T236* C,T0* a1,T2 a2){ +if((a2)==(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)))){ +r236add_last(C,a1); +} +else{ +/*l53c5/arrayed_collection.e*/ +r236add_last(C,a1); +/*l54c5/arrayed_collection.e*/ +r236move(C,a2,((int32_t)((/*RF2*/(C)->_upper/*3p*/)))-(INT32_C(1)),INT32_C(1)); +/*l122c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[a2]=(a1); +} +}/*--*/ + +/*FAST_ARRAY[JOB]*/void r236move(T236* C,T2 a1,T2 a2,T2 a3){ +T0* _default_value=(void*)0; +T2 _i=0; +if((a3)==(INT8_C(0))){ +} +else if(((int32_t)(a3))<(INT32_C(0))){ +_i=a1; +while (!(((int32_t)(_i))>(a2))) +{ +/*l122c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))+(a3)]=(((/*RF2*/(C)->_storage/*3p*/))[_i]); +/*l122c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[_i]=(_default_value); +/*l618c6/collection.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +else{ +_i=a2; +while (!(((int32_t)(_i))<(a1))) +{ +/*l122c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[((int32_t)(_i))+(a3)]=(((/*RF2*/(C)->_storage/*3p*/))[_i]); +/*l122c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[_i]=(_default_value); +/*l628c6/collection.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +} +}/*--*/ + +/*FAST_ARRAY[EVENT_CATCHER]*/void r235make(T235* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new287(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r287clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[EVENT_CATCHER]*/void r235mark_native_arrays(T235* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark128((T128*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r232make(T232* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new281(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r281clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r232mark_native_arrays(T232* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark234((T234*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[TOPLEVEL_WINDOW]*/void r225make(T225* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new262(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r262clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[TOPLEVEL_WINDOW]*/void r225mark_native_arrays(T225* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[KEY_RANGE]*/void r223make(T223* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new261(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r261clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[KEY_RANGE]*/void r223add_last(T223* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new261(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r261realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[KEY_RANGE]*/void r223mark_native_arrays(T223* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark139((T139*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[BUTTON_RANGE]*/void r222make(T222* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new260(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r260clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[BUTTON_RANGE]*/void r222add_last(T222* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new260(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r260realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[BUTTON_RANGE]*/void r222mark_native_arrays(T222* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark142((T142*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[AXES_RANGE]*/void r221make(T221* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new259(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r259clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[AXES_RANGE]*/void r221add_last(T221* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new259(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r259realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[AXES_RANGE]*/void r221mark_native_arrays(T221* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark141((T141*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r217make(T217* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new255(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r255clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r217mark_native_arrays(T217* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark216((T216*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[INTEGER_32]*/void r214make(T214* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new250(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r250clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[INTEGER_32]*/T2 r214count(T214* C){ +T2 R=0; +R=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +return R; +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/void r207copy(T207* C,T0* a1){ +T2 _other_upper=0; +T2 _new_capacity=0; +/*l174c4/fast_array.e*/ +_other_upper=(/*RF2*/(((T207*)a1))->_upper/*3p*/); +/*l175c4/fast_array.e*/ +if(((int32_t)(_other_upper))>=(INT32_C(0))){ +/*l176c5/fast_array.e*/ +_new_capacity=((int32_t)(_other_upper))+(INT32_C(1)); +/*l177c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))<(_new_capacity)){ +/*l178c6/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new238(_new_capacity); +/*l179c6/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +} +else if(((int32_t)(_new_capacity))<((/*RF2*/(C)->_capacity/*3p*/))){ +r238clear((/*RF2*/(C)->_storage/*3p*/),_new_capacity,((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1))); +} +/*l183c13/fast_array.e*/ +r238copy_from((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(((T207*)a1))->_storage/*3p*/),_other_upper); +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +r238clear_all((/*RF2*/(C)->_storage/*3p*/),((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1))); +} +/*l187c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=_other_upper; +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/void r207remove(T207* C,T2 a1){ +/*l343c12/fast_array.e*/ +r238remove((/*RF2*/(C)->_storage/*3p*/),a1,(/*RF2*/(C)->_upper/*3p*/)); +/*l344c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/void r207make(T207* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new238(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r238clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/void r207add_last(T207* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new238(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r238realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/void r207mark_native_arrays(T207* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark146((T146*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[IVY_CLIENT]*/T2 r207fast_index_of(T207* C,T0* a1,T2 a2){ +T2 R=0; +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +R=r238fast_index_of((/*RF2*/(C)->_storage/*3p*/),a1,a2,(/*RF2*/(C)->_upper/*3p*/)); +} +return R; +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/void r206remove_last(T206* C){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/void r206make(T206* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new237(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r237clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/void r206add_last(T206* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new237(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r237realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/T0* r206last(T206* C){ +T0* R=(void*)0; +R=((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]; +return R; +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/T6 r206is_empty(T206* C){ +T6 R=0; +R=((T6)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))<(INT32_C(0)))); +return R; +}/*--*/ + +/*FAST_ARRAY[LOOP_ITEM]*/void r206mark_native_arrays(T206* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark148((T148*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[X_INPUT_DEVICE]*/void r205make(T205* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new220(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r220clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[X_INPUT_DEVICE]*/void r205mark_native_arrays(T205* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark67((T67*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*FAST_ARRAY[STRING]*/void r204make(T204* C,T2 a1){ +/*l39c4/fast_array.e*/ +if(((int32_t)(a1))>((/*RF2*/(C)->_capacity/*3p*/))){ +/*l41c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new219(a1); +/*l42c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(INT32_C(0))){ +/*l45c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=r2max((/*RF2*/(C)->_upper/*3p*/),((int32_t)(a1))-(INT32_C(1))); +/*l46c5/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))>=(INT32_C(0))){ +r219clear_all((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_upper/*3p*/)); +} +} +/*l50c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)(a1))-(INT32_C(1)); +}/*--*/ + +/*FAST_ARRAY[STRING]*/void r204add_last(T204* C,T0* a1){ +T2 _new_capacity=0; +/*l141c4/fast_array.e*/ +if(((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1))))<=(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))-(INT32_C(1)))){ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +else if(((/*RF2*/(C)->_capacity/*3p*/))==(INT8_C(0))){ +/*l144c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new219(INT32_C(2)); +/*l145c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(2); +/*l146c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(0); +} +else{ +/*l148c5/fast_array.e*/ +_new_capacity=((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))*(INT32_C(2)); +/*l149c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=r219realloc((/*RF2*/(C)->_storage/*3p*/),(/*RF2*/(C)->_capacity/*3p*/),_new_capacity); +/*l150c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=_new_capacity; +/*l151c5/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=((int32_t)((/*RF2*/(C)->_upper/*3p*/)))+(INT32_C(1)); +} +/*l153c12/fast_array.e*/ +((/*RF2*/(C)->_storage/*3p*/))[(/*RF2*/(C)->_upper/*3p*/)]=(a1); +}/*--*/ + +/*FAST_ARRAY[STRING]*/void r204with_capacity(T204* C,T2 a1){ +/*l62c4/fast_array.e*/ +if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))<(a1)){ +/*l63c5/fast_array.e*/ +/*SFN*/(C->_storage/*3p*/)=new219(a1); +/*l64c5/fast_array.e*/ +/*SFN*/(C->_capacity/*3p*/)=a1; +} +else if(((int32_t)((/*RF2*/(C)->_capacity/*3p*/)))>(a1)){ +r219clear((/*RF2*/(C)->_storage/*3p*/),INT32_C(0),(/*RF2*/(C)->_upper/*3p*/)); +} +/*l68c4/fast_array.e*/ +/*SFN*/(C->_upper/*3p*/)=INT32_C(-1); +}/*--*/ + +/*FAST_ARRAY[STRING]*/void r204mark_native_arrays(T204* C){ +T2 _i=0; +_i=(/*RF2*/(C)->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l370c5/fast_array.e*/ +{/*mark_item*/ +T0* elt=(/*RF2*/(C)->_storage/*3p*/)[_i]; +if(NULL!=elt)gc_mark7((T7*)(elt)); +/*mark_item*/}/*l371c5/fast_array.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]*/void r286set_item(T286* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]*/void r277set_item(T277* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]*/void r271set_item(T271* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]*/void r268set_item(T268* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]*/void r266make(T266* C,T0* a1,T8 a2,T0* a3){ +/*l38c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_item/*3p*/)=a1; +/*l39c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_key/*3p*/)=a2; +/*l40c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_next/*3p*/)=a3; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]*/void r265set_item(T265* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]*/void r264make(T264* C,T0* a1,T2 a2,T0* a3){ +/*l38c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_item/*3p*/)=a1; +/*l39c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_key/*3p*/)=a2; +/*l40c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_next/*3p*/)=a3; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]*/void r258set_item(T258* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r256make(T256* C,T0* a1,T0* a2,T0* a3){ +/*l38c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_item/*3p*/)=a1; +/*l39c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_key/*3p*/)=a2; +/*l40c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_next/*3p*/)=a3; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]*/void r253set_item(T253* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]*/void r252make(T252* C,T2 a1,T2 a2,T0* a3){ +/*l38c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_item/*3p*/)=a1; +/*l39c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_key/*3p*/)=a2; +/*l40c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_next/*3p*/)=a3; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[POINTER,STRING]]*/void r249set_item(T249* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r246make(T246* C,T0* a1,T0* a2,T0* a3){ +/*l38c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_item/*3p*/)=a1; +/*l39c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_key/*3p*/)=a2; +/*l40c4/hashed_dictionary_node.e*/ +/*SFN*/(C->_next/*3p*/)=a3; +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]*/void r245set_item(T245* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T2 r244prime_capacity(T2 a1){ +T2 R=0; +/*l138c4/hash_table_size.e*/ +R=(int32_t)(((uint32_t)(a1))+((uint32_t)(((int32_t)(a1))/(INT32_C(2))))); +/*l139c4/hash_table_size.e*/ +if(((int32_t)(R))>(INT32_C(0))){ +R=r244prime_number_ceiling(R); +} +else{ +R=r244prime_number_ceiling(INT32_C(2147483647)); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T2 r244prime_number_ceiling(T2 a1){ +T2 R=0; +if(((int32_t)(a1))<=(INT32_C(98317))){ +if(((int32_t)(a1))<=(INT32_C(769))){ +if(((int32_t)(a1))<=(INT32_C(53))){ +if(((int32_t)(a1))<=(INT32_C(11))){ +R=INT32_C(11); +} +else if(((int32_t)(a1))<=(INT32_C(23))){ +R=INT32_C(23); +} +else{ +R=INT32_C(53); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(193))){ +if(((int32_t)(a1))<=(INT32_C(97))){ +R=INT32_C(97); +} +else{ +R=INT32_C(193); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(389))){ +R=INT32_C(389); +} +else{ +R=INT32_C(769); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12289))){ +if(((int32_t)(a1))<=(INT32_C(3079))){ +if(((int32_t)(a1))<=(INT32_C(1543))){ +R=INT32_C(1543); +} +else{ +R=INT32_C(3079); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(6151))){ +R=INT32_C(6151); +} +else{ +R=INT32_C(12289); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(24593))){ +R=INT32_C(24593); +} +else if(((int32_t)(a1))<=(INT32_C(49157))){ +R=INT32_C(49157); +} +else{ +R=INT32_C(98317); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12582917))){ +if(((int32_t)(a1))<=(INT32_C(1572869))){ +if(((int32_t)(a1))<=(INT32_C(393241))){ +if(((int32_t)(a1))<=(INT32_C(196613))){ +R=INT32_C(196613); +} +else{ +R=INT32_C(393241); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(786433))){ +R=INT32_C(786433); +} +else{ +R=INT32_C(1572869); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(3145739))){ +R=INT32_C(3145739); +} +else if(((int32_t)(a1))<=(INT32_C(6291469))){ +R=INT32_C(6291469); +} +else{ +R=INT32_C(12582917); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(201326611))){ +if(((int32_t)(a1))<=(INT32_C(50331653))){ +if(((int32_t)(a1))<=(INT32_C(25165843))){ +R=INT32_C(25165843); +} +else{ +R=INT32_C(50331653); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(100663319))){ +R=INT32_C(100663319); +} +else{ +R=INT32_C(201326611); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(805306457))){ +if(((int32_t)(a1))<=(INT32_C(402653189))){ +R=INT32_C(402653189); +} +else{ +R=INT32_C(805306457); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(1610612741))){ +R=INT32_C(1610612741); +} +else{ +R=INT32_C(2147483647); +} +} +} +} +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T6 r244should_increase_capacity(T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(a2))>((int32_t)(((uint32_t)(((int32_t)(a1))/(INT32_C(3))))*((uint32_t)(INT32_C(2))))))&&((T6)(((int32_t)(a1))<(INT32_C(2147483647))))))); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T0* r244new_node(T244* C,T0* a1,T0* a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l519c4/hashed_dictionary.e*/ +R=(/*RF2*/((T245*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/); +/*l520c4/hashed_dictionary.e*/ +if((R)==((void*)((void*)0))){ +tmp0=((T0*)(new246())); +r246make(((T246*)tmp0),a1,a2,a3); +R=tmp0; +} +else{ +/*l29c4/weak_reference.e*/ +(/*RF2*/((T245*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/)=(/*RF2*/(((T246*)R))->_next/*3p*/); +/*l524c12/hashed_dictionary.e*/ +r246make(((T246*)R),a1,a2,a3); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244add(T244* C,T0* a1,T0* a2){ +T2 _idx=0; +T0* _node=(void*)0; +/*l193c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l194c4/hashed_dictionary.e*/ +if(r244should_increase_capacity((/*RF2*/(C)->_capacity/*5p*/),(/*RF2*/(C)->_count/*5p*/))){ +r244increase_capacity(C); +} +/*l197c4/hashed_dictionary.e*/ +_idx=((int32_t)(r7hash_code(((T7*)a2))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l198c4/hashed_dictionary.e*/ +_node=r244new_node(C,a1,a2,((/*RF2*/(C)->_buckets/*5p*/))[_idx]); +/*l199c12/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node); +/*l200c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=((int32_t)((/*RF2*/(C)->_count/*5p*/)))+(INT32_C(1)); +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T0* r244fast_reference_at(T244* C,T0* a1){ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l121c4/hashed_dictionary.e*/ +/*l122c5/hashed_dictionary.e*/ +_idx=((int32_t)(r7hash_code(((T7*)a1))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l123c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(((/*RF2*/(((T246*)_node))->_key/*3p*/))==((void*)(a1))))))) +{ +_node=(/*RF2*/(((T246*)_node))->_next/*3p*/); +} +/*l129c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(/*RF2*/(((T246*)_node))->_item/*3p*/); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244special_common_dictionary(T244* C,T0* a1){ +T2 _new_capacity=0; +/*l578c4/hashed_dictionary.e*/ +_new_capacity=INT32_C(53); +/*l579c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new289(_new_capacity); +/*l580c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +/*l581c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l582c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +/*l583c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244increase_capacity(T244* C){ +T2 _i=0; +T2 _idx=0; +T2 _new_capacity=0; +T289 _old_buckets=(void*)0; +T0* _node1=(void*)0; +T0* _node2=(void*)0; +/*l409c4/hashed_dictionary.e*/ +/*l410c5/hashed_dictionary.e*/ +_new_capacity=r244prime_capacity(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+(INT32_C(1))); +/*l411c5/hashed_dictionary.e*/ +_old_buckets=(/*RF2*/(C)->_buckets/*5p*/); +/*l412c5/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new289(_new_capacity); +/*l413c5/hashed_dictionary.e*/ +_i=((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1)); +/*l414c5/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l418c5/hashed_dictionary.e*/ +_node1=(_old_buckets)[_i]; +while (!((_node1)==((void*)((void*)0)))) +{ +/*l423c6/hashed_dictionary.e*/ +_node2=(/*RF2*/(((T246*)_node1))->_next/*3p*/); +/*l424c6/hashed_dictionary.e*/ +_idx=((int32_t)(r7hash_code((T7*)((/*RF2*/(((T246*)_node1))->_key/*3p*/)))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l31c4/hashed_dictionary_node.e*/ +(/*RF2*/(((T246*)_node1))->_next/*3p*/)=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +/*l426c14/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node1); +/*l427c6/hashed_dictionary.e*/ +_node1=_node2; +} +/*l429c5/hashed_dictionary.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l431c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +}/*--*/ + +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]*/void r243set_item(T243* C,T0* a1){ +/*SFN*/(C->_item/*ip*/)=a1; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/void r234make(T234* C){ +r234create_with_capacity(C,INT32_C(53)); +}/*--*/ +/*l78c40/hashed_dictionary.e*/ +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T0* r234reference_at(T234* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code(((T72*)a1))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r234key_safe_equal((T0*)(/*se_evobt*/_node,se_print_run_time_stack(),exit(1),tmp0=(void*)0),a1)))))) +{ +_node=(void*)0; +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(void*)0; +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T6 r234key_safe_equal(T0* a1,T0* a2){ +T6 R=0; +if((a1)==((void*)(a2))){ +R=((T6)(1)); +} +else{ +R=((T6)(!memcmp(((T72*)a1),(a2),sizeof(T72)))); +} +return R; +}/*--*/ +T0*oBC136common_free_nodes=(void*)0; +int fBC136common_free_nodes=0; + +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T0* r234common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/void r234create_with_capacity(T234* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r234common_free_nodes()),(T0*)(t[234])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new286())); +r286set_item(((T286*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r234common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[234])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new284(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/void r230make(T230* C){ +r230create_with_capacity(C,INT32_C(53)); +}/*--*/ +/*l78c40/hashed_dictionary.e*/ +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r230reference_at(T230* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code(((T72*)a1))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r230key_safe_equal((T0*)(/*se_evobt*/_node,se_print_run_time_stack(),exit(1),tmp0=(void*)0),a1)))))) +{ +_node=(void*)0; +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(void*)0; +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T6 r230key_safe_equal(T0* a1,T0* a2){ +T6 R=0; +if((a1)==((void*)(a2))){ +R=((T6)(1)); +} +else{ +R=((T6)(!memcmp(((T72*)a1),(a2),sizeof(T72)))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r230common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/void r230create_with_capacity(T230* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r230common_free_nodes()),(T0*)(t[230])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new277())); +r277set_item(((T277*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r230common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[230])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new276(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/void r228make(T228* C){ +r228create_with_capacity(C,INT32_C(53)); +}/*--*/ +/*l78c40/hashed_dictionary.e*/ +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r228reference_at(T228* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code(((T72*)a1))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r228key_safe_equal((T0*)(/*se_evobt*/_node,se_print_run_time_stack(),exit(1),tmp0=(void*)0),a1)))))) +{ +_node=(void*)0; +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(void*)0; +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T6 r228key_safe_equal(T0* a1,T0* a2){ +T6 R=0; +if((a1)==((void*)(a2))){ +R=((T6)(1)); +} +else{ +R=((T6)(!memcmp(((T72*)a1),(a2),sizeof(T72)))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r228common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/void r228create_with_capacity(T228* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r228common_free_nodes()),(T0*)(t[228])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new271())); +r271set_item(((T271*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r228common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[228])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new270(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227make(T227* C){ +r227create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T2 r227prime_capacity(T2 a1){ +T2 R=0; +/*l138c4/hash_table_size.e*/ +R=(int32_t)(((uint32_t)(a1))+((uint32_t)(((int32_t)(a1))/(INT32_C(2))))); +/*l139c4/hash_table_size.e*/ +if(((int32_t)(R))>(INT32_C(0))){ +R=r227prime_number_ceiling(R); +} +else{ +R=r227prime_number_ceiling(INT32_C(2147483647)); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T2 r227prime_number_ceiling(T2 a1){ +T2 R=0; +if(((int32_t)(a1))<=(INT32_C(98317))){ +if(((int32_t)(a1))<=(INT32_C(769))){ +if(((int32_t)(a1))<=(INT32_C(53))){ +if(((int32_t)(a1))<=(INT32_C(11))){ +R=INT32_C(11); +} +else if(((int32_t)(a1))<=(INT32_C(23))){ +R=INT32_C(23); +} +else{ +R=INT32_C(53); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(193))){ +if(((int32_t)(a1))<=(INT32_C(97))){ +R=INT32_C(97); +} +else{ +R=INT32_C(193); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(389))){ +R=INT32_C(389); +} +else{ +R=INT32_C(769); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12289))){ +if(((int32_t)(a1))<=(INT32_C(3079))){ +if(((int32_t)(a1))<=(INT32_C(1543))){ +R=INT32_C(1543); +} +else{ +R=INT32_C(3079); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(6151))){ +R=INT32_C(6151); +} +else{ +R=INT32_C(12289); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(24593))){ +R=INT32_C(24593); +} +else if(((int32_t)(a1))<=(INT32_C(49157))){ +R=INT32_C(49157); +} +else{ +R=INT32_C(98317); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12582917))){ +if(((int32_t)(a1))<=(INT32_C(1572869))){ +if(((int32_t)(a1))<=(INT32_C(393241))){ +if(((int32_t)(a1))<=(INT32_C(196613))){ +R=INT32_C(196613); +} +else{ +R=INT32_C(393241); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(786433))){ +R=INT32_C(786433); +} +else{ +R=INT32_C(1572869); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(3145739))){ +R=INT32_C(3145739); +} +else if(((int32_t)(a1))<=(INT32_C(6291469))){ +R=INT32_C(6291469); +} +else{ +R=INT32_C(12582917); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(201326611))){ +if(((int32_t)(a1))<=(INT32_C(50331653))){ +if(((int32_t)(a1))<=(INT32_C(25165843))){ +R=INT32_C(25165843); +} +else{ +R=INT32_C(50331653); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(100663319))){ +R=INT32_C(100663319); +} +else{ +R=INT32_C(201326611); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(805306457))){ +if(((int32_t)(a1))<=(INT32_C(402653189))){ +R=INT32_C(402653189); +} +else{ +R=INT32_C(805306457); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(1610612741))){ +R=INT32_C(1610612741); +} +else{ +R=INT32_C(2147483647); +} +} +} +} +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T6 r227should_increase_capacity(T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(a2))>((int32_t)(((uint32_t)(((int32_t)(a1))/(INT32_C(3))))*((uint32_t)(INT32_C(2))))))&&((T6)(((int32_t)(a1))<(INT32_C(2147483647))))))); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227reference_at(T227* C,T8 a1){ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)(r8hash_code(a1)))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r227key_safe_equal((/*RF2*/(((T266*)_node))->_key/*3p*/),a1)))))) +{ +_node=(/*RF2*/(((T266*)_node))->_next/*3p*/); +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(/*RF2*/(((T266*)_node))->_item/*3p*/); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T6 r227key_safe_equal(T8 a1,T8 a2){ +T6 R=0; +if((a1)==(a2)){ +R=((T6)(1)); +} +else{ +R=((T6)((a1)==(a2))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227new_node(T227* C,T0* a1,T8 a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l519c4/hashed_dictionary.e*/ +R=(/*RF2*/((T268*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/); +/*l520c4/hashed_dictionary.e*/ +if((R)==((void*)((void*)0))){ +tmp0=((T0*)(new266())); +r266make(((T266*)tmp0),a1,a2,a3); +R=tmp0; +} +else{ +/*l29c4/weak_reference.e*/ +(/*RF2*/((T268*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/)=(/*RF2*/(((T266*)R))->_next/*3p*/); +/*l524c12/hashed_dictionary.e*/ +r266make(((T266*)R),a1,a2,a3); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227add(T227* C,T0* a1,T8 a2){ +T2 _idx=0; +T0* _node=(void*)0; +/*l193c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l194c4/hashed_dictionary.e*/ +if(r227should_increase_capacity((/*RF2*/(C)->_capacity/*5p*/),(/*RF2*/(C)->_count/*5p*/))){ +r227increase_capacity(C); +} +/*l197c4/hashed_dictionary.e*/ +_idx=((int32_t)(r8hash_code(a2)))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l198c4/hashed_dictionary.e*/ +_node=r227new_node(C,a1,a2,((/*RF2*/(C)->_buckets/*5p*/))[_idx]); +/*l199c12/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node); +/*l200c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=((int32_t)((/*RF2*/(C)->_count/*5p*/)))+(INT32_C(1)); +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227create_with_capacity(T227* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r227common_free_nodes()),(T0*)(t[227])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new268())); +r268set_item(((T268*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r227common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[227])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new267(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227increase_capacity(T227* C){ +T2 _i=0; +T2 _idx=0; +T2 _new_capacity=0; +T267 _old_buckets=(void*)0; +T0* _node1=(void*)0; +T0* _node2=(void*)0; +/*l409c4/hashed_dictionary.e*/ +/*l410c5/hashed_dictionary.e*/ +_new_capacity=r227prime_capacity(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+(INT32_C(1))); +/*l411c5/hashed_dictionary.e*/ +_old_buckets=(/*RF2*/(C)->_buckets/*5p*/); +/*l412c5/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new267(_new_capacity); +/*l413c5/hashed_dictionary.e*/ +_i=((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1)); +/*l414c5/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l418c5/hashed_dictionary.e*/ +_node1=(_old_buckets)[_i]; +while (!((_node1)==((void*)((void*)0)))) +{ +/*l423c6/hashed_dictionary.e*/ +_node2=(/*RF2*/(((T266*)_node1))->_next/*3p*/); +/*l424c6/hashed_dictionary.e*/ +_idx=((int32_t)(r8hash_code((/*RF2*/(((T266*)_node1))->_key/*3p*/))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l31c4/hashed_dictionary_node.e*/ +(/*RF2*/(((T266*)_node1))->_next/*3p*/)=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +/*l426c14/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node1); +/*l427c6/hashed_dictionary.e*/ +_node1=_node2; +} +/*l429c5/hashed_dictionary.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l431c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226put(T226* C,T0* a1,T2 a2){ +T2 _h=0; +T2 _idx=0; +T0* _node=(void*)0; +/*l139c4/hashed_dictionary.e*/ +/*l140c5/hashed_dictionary.e*/ +_h=(a2&/*0x7FFFFFFF*/INT32_C(2147483647)); +/*l141c5/hashed_dictionary.e*/ +_idx=((int32_t)(_h))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l142c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r226key_safe_equal((/*RF2*/(((T264*)_node))->_key/*3p*/),a2)))))) +{ +_node=(/*RF2*/(((T264*)_node))->_next/*3p*/); +} +/*l148c4/hashed_dictionary.e*/ +if((_node)==((void*)((void*)0))){ +/*l149c5/hashed_dictionary.e*/ +if(r226should_increase_capacity((/*RF2*/(C)->_capacity/*5p*/),(/*RF2*/(C)->_count/*5p*/))){ +/*l150c6/hashed_dictionary.e*/ +r226increase_capacity(C); +/*l151c6/hashed_dictionary.e*/ +_idx=((int32_t)(_h))%((/*RF2*/(C)->_capacity/*5p*/)); +} +/*l153c5/hashed_dictionary.e*/ +_node=r226new_node(C,a1,a2,((/*RF2*/(C)->_buckets/*5p*/))[_idx]); +/*l154c13/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node); +/*l155c5/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=((int32_t)((/*RF2*/(C)->_count/*5p*/)))+(INT32_C(1)); +/*l156c5/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +} +else{ +(/*RF2*/(((T264*)_node))->_item/*3p*/)=a1; +} +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226make(T226* C){ +r226create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T2 r226prime_capacity(T2 a1){ +T2 R=0; +/*l138c4/hash_table_size.e*/ +R=(int32_t)(((uint32_t)(a1))+((uint32_t)(((int32_t)(a1))/(INT32_C(2))))); +/*l139c4/hash_table_size.e*/ +if(((int32_t)(R))>(INT32_C(0))){ +R=r226prime_number_ceiling(R); +} +else{ +R=r226prime_number_ceiling(INT32_C(2147483647)); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T2 r226prime_number_ceiling(T2 a1){ +T2 R=0; +if(((int32_t)(a1))<=(INT32_C(98317))){ +if(((int32_t)(a1))<=(INT32_C(769))){ +if(((int32_t)(a1))<=(INT32_C(53))){ +if(((int32_t)(a1))<=(INT32_C(11))){ +R=INT32_C(11); +} +else if(((int32_t)(a1))<=(INT32_C(23))){ +R=INT32_C(23); +} +else{ +R=INT32_C(53); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(193))){ +if(((int32_t)(a1))<=(INT32_C(97))){ +R=INT32_C(97); +} +else{ +R=INT32_C(193); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(389))){ +R=INT32_C(389); +} +else{ +R=INT32_C(769); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12289))){ +if(((int32_t)(a1))<=(INT32_C(3079))){ +if(((int32_t)(a1))<=(INT32_C(1543))){ +R=INT32_C(1543); +} +else{ +R=INT32_C(3079); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(6151))){ +R=INT32_C(6151); +} +else{ +R=INT32_C(12289); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(24593))){ +R=INT32_C(24593); +} +else if(((int32_t)(a1))<=(INT32_C(49157))){ +R=INT32_C(49157); +} +else{ +R=INT32_C(98317); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12582917))){ +if(((int32_t)(a1))<=(INT32_C(1572869))){ +if(((int32_t)(a1))<=(INT32_C(393241))){ +if(((int32_t)(a1))<=(INT32_C(196613))){ +R=INT32_C(196613); +} +else{ +R=INT32_C(393241); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(786433))){ +R=INT32_C(786433); +} +else{ +R=INT32_C(1572869); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(3145739))){ +R=INT32_C(3145739); +} +else if(((int32_t)(a1))<=(INT32_C(6291469))){ +R=INT32_C(6291469); +} +else{ +R=INT32_C(12582917); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(201326611))){ +if(((int32_t)(a1))<=(INT32_C(50331653))){ +if(((int32_t)(a1))<=(INT32_C(25165843))){ +R=INT32_C(25165843); +} +else{ +R=INT32_C(50331653); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(100663319))){ +R=INT32_C(100663319); +} +else{ +R=INT32_C(201326611); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(805306457))){ +if(((int32_t)(a1))<=(INT32_C(402653189))){ +R=INT32_C(402653189); +} +else{ +R=INT32_C(805306457); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(1610612741))){ +R=INT32_C(1610612741); +} +else{ +R=INT32_C(2147483647); +} +} +} +} +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T6 r226should_increase_capacity(T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(a2))>((int32_t)(((uint32_t)(((int32_t)(a1))/(INT32_C(3))))*((uint32_t)(INT32_C(2))))))&&((T6)(((int32_t)(a1))<(INT32_C(2147483647))))))); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226reference_at(T226* C,T2 a1){ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)((a1&/*0x7FFFFFFF*/INT32_C(2147483647))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r226key_safe_equal((/*RF2*/(((T264*)_node))->_key/*3p*/),a1)))))) +{ +_node=(/*RF2*/(((T264*)_node))->_next/*3p*/); +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(/*RF2*/(((T264*)_node))->_item/*3p*/); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T6 r226key_safe_equal(T2 a1,T2 a2){ +T6 R=0; +if((a1)==(a2)){ +R=((T6)(1)); +} +else{ +R=((T6)((a1)==(a2))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226new_node(T226* C,T0* a1,T2 a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l519c4/hashed_dictionary.e*/ +R=(/*RF2*/((T265*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/); +/*l520c4/hashed_dictionary.e*/ +if((R)==((void*)((void*)0))){ +tmp0=((T0*)(new264())); +r264make(((T264*)tmp0),a1,a2,a3); +R=tmp0; +} +else{ +/*l29c4/weak_reference.e*/ +(/*RF2*/((T265*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/)=(/*RF2*/(((T264*)R))->_next/*3p*/); +/*l524c12/hashed_dictionary.e*/ +r264make(((T264*)R),a1,a2,a3); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226create_with_capacity(T226* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r226common_free_nodes()),(T0*)(t[226])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new265())); +r265set_item(((T265*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r226common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[226])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new263(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226increase_capacity(T226* C){ +T2 _i=0; +T2 _idx=0; +T2 _new_capacity=0; +T263 _old_buckets=(void*)0; +T0* _node1=(void*)0; +T0* _node2=(void*)0; +/*l409c4/hashed_dictionary.e*/ +/*l410c5/hashed_dictionary.e*/ +_new_capacity=r226prime_capacity(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+(INT32_C(1))); +/*l411c5/hashed_dictionary.e*/ +_old_buckets=(/*RF2*/(C)->_buckets/*5p*/); +/*l412c5/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new263(_new_capacity); +/*l413c5/hashed_dictionary.e*/ +_i=((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1)); +/*l414c5/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l418c5/hashed_dictionary.e*/ +_node1=(_old_buckets)[_i]; +while (!((_node1)==((void*)((void*)0)))) +{ +/*l423c6/hashed_dictionary.e*/ +_node2=(/*RF2*/(((T264*)_node1))->_next/*3p*/); +/*l424c6/hashed_dictionary.e*/ +_idx=((int32_t)(((/*RF2*/(((T264*)_node1))->_key/*3p*/)&/*0x7FFFFFFF*/INT32_C(2147483647))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l31c4/hashed_dictionary_node.e*/ +(/*RF2*/(((T264*)_node1))->_next/*3p*/)=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +/*l426c14/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node1); +/*l427c6/hashed_dictionary.e*/ +_node1=_node2; +} +/*l429c5/hashed_dictionary.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l431c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218make(T218* C){ +r218create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T2 r218prime_capacity(T2 a1){ +T2 R=0; +/*l138c4/hash_table_size.e*/ +R=(int32_t)(((uint32_t)(a1))+((uint32_t)(((int32_t)(a1))/(INT32_C(2))))); +/*l139c4/hash_table_size.e*/ +if(((int32_t)(R))>(INT32_C(0))){ +R=r218prime_number_ceiling(R); +} +else{ +R=r218prime_number_ceiling(INT32_C(2147483647)); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T2 r218prime_number_ceiling(T2 a1){ +T2 R=0; +if(((int32_t)(a1))<=(INT32_C(98317))){ +if(((int32_t)(a1))<=(INT32_C(769))){ +if(((int32_t)(a1))<=(INT32_C(53))){ +if(((int32_t)(a1))<=(INT32_C(11))){ +R=INT32_C(11); +} +else if(((int32_t)(a1))<=(INT32_C(23))){ +R=INT32_C(23); +} +else{ +R=INT32_C(53); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(193))){ +if(((int32_t)(a1))<=(INT32_C(97))){ +R=INT32_C(97); +} +else{ +R=INT32_C(193); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(389))){ +R=INT32_C(389); +} +else{ +R=INT32_C(769); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12289))){ +if(((int32_t)(a1))<=(INT32_C(3079))){ +if(((int32_t)(a1))<=(INT32_C(1543))){ +R=INT32_C(1543); +} +else{ +R=INT32_C(3079); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(6151))){ +R=INT32_C(6151); +} +else{ +R=INT32_C(12289); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(24593))){ +R=INT32_C(24593); +} +else if(((int32_t)(a1))<=(INT32_C(49157))){ +R=INT32_C(49157); +} +else{ +R=INT32_C(98317); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12582917))){ +if(((int32_t)(a1))<=(INT32_C(1572869))){ +if(((int32_t)(a1))<=(INT32_C(393241))){ +if(((int32_t)(a1))<=(INT32_C(196613))){ +R=INT32_C(196613); +} +else{ +R=INT32_C(393241); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(786433))){ +R=INT32_C(786433); +} +else{ +R=INT32_C(1572869); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(3145739))){ +R=INT32_C(3145739); +} +else if(((int32_t)(a1))<=(INT32_C(6291469))){ +R=INT32_C(6291469); +} +else{ +R=INT32_C(12582917); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(201326611))){ +if(((int32_t)(a1))<=(INT32_C(50331653))){ +if(((int32_t)(a1))<=(INT32_C(25165843))){ +R=INT32_C(25165843); +} +else{ +R=INT32_C(50331653); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(100663319))){ +R=INT32_C(100663319); +} +else{ +R=INT32_C(201326611); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(805306457))){ +if(((int32_t)(a1))<=(INT32_C(402653189))){ +R=INT32_C(402653189); +} +else{ +R=INT32_C(805306457); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(1610612741))){ +R=INT32_C(1610612741); +} +else{ +R=INT32_C(2147483647); +} +} +} +} +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218reference_at(T218* C,T0* a1){ +T0* R=(void*)0; +T2 _idx=0; +T0* _node=(void*)0; +/*l74c4/hashed_dictionary.e*/ +/*l75c5/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code(((T72*)a1))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l76c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r218key_safe_equal((/*RF2*/(((T256*)_node))->_key/*3p*/),a1)))))) +{ +_node=(/*RF2*/(((T256*)_node))->_next/*3p*/); +} +/*l82c4/hashed_dictionary.e*/ +if((_node)!=((void*)((void*)0))){ +R=(/*RF2*/(((T256*)_node))->_item/*3p*/); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T6 r218should_increase_capacity(T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(a2))>((int32_t)(((uint32_t)(((int32_t)(a1))/(INT32_C(3))))*((uint32_t)(INT32_C(2))))))&&((T6)(((int32_t)(a1))<(INT32_C(2147483647))))))); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T6 r218key_safe_equal(T0* a1,T0* a2){ +T6 R=0; +if((a1)==((void*)(a2))){ +R=((T6)(1)); +} +else{ +R=((T6)(!memcmp(((T72*)a1),(a2),sizeof(T72)))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218new_node(T218* C,T0* a1,T0* a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l519c4/hashed_dictionary.e*/ +R=(/*RF2*/((T258*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/); +/*l520c4/hashed_dictionary.e*/ +if((R)==((void*)((void*)0))){ +tmp0=((T0*)(new256())); +r256make(((T256*)tmp0),a1,a2,a3); +R=tmp0; +} +else{ +/*l29c4/weak_reference.e*/ +(/*RF2*/((T258*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/)=(/*RF2*/(((T256*)R))->_next/*3p*/); +/*l524c12/hashed_dictionary.e*/ +r256make(((T256*)R),a1,a2,a3); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218add(T218* C,T0* a1,T0* a2){ +T2 _idx=0; +T0* _node=(void*)0; +/*l193c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l194c4/hashed_dictionary.e*/ +if(r218should_increase_capacity((/*RF2*/(C)->_capacity/*5p*/),(/*RF2*/(C)->_count/*5p*/))){ +r218increase_capacity(C); +} +/*l197c4/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code(((T72*)a2))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l198c4/hashed_dictionary.e*/ +_node=r218new_node(C,a1,a2,((/*RF2*/(C)->_buckets/*5p*/))[_idx]); +/*l199c12/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node); +/*l200c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=((int32_t)((/*RF2*/(C)->_count/*5p*/)))+(INT32_C(1)); +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218create_with_capacity(T218* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r218common_free_nodes()),(T0*)(t[218])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new258())); +r258set_item(((T258*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r218common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[218])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new257(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218increase_capacity(T218* C){ +T2 _i=0; +T2 _idx=0; +T2 _new_capacity=0; +T257 _old_buckets=(void*)0; +T0* _node1=(void*)0; +T0* _node2=(void*)0; +/*l409c4/hashed_dictionary.e*/ +/*l410c5/hashed_dictionary.e*/ +_new_capacity=r218prime_capacity(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+(INT32_C(1))); +/*l411c5/hashed_dictionary.e*/ +_old_buckets=(/*RF2*/(C)->_buckets/*5p*/); +/*l412c5/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new257(_new_capacity); +/*l413c5/hashed_dictionary.e*/ +_i=((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1)); +/*l414c5/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l418c5/hashed_dictionary.e*/ +_node1=(_old_buckets)[_i]; +while (!((_node1)==((void*)((void*)0)))) +{ +/*l423c6/hashed_dictionary.e*/ +_node2=(/*RF2*/(((T256*)_node1))->_next/*3p*/); +/*l424c6/hashed_dictionary.e*/ +_idx=((int32_t)(r72hash_code((T72*)((/*RF2*/(((T256*)_node1))->_key/*3p*/)))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l31c4/hashed_dictionary_node.e*/ +(/*RF2*/(((T256*)_node1))->_next/*3p*/)=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +/*l426c14/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node1); +/*l427c6/hashed_dictionary.e*/ +_node1=_node2; +} +/*l429c5/hashed_dictionary.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l431c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +}/*--*/ + +/*SIGNAL_1[X_INPUT_DEVICE]*/void r216make(T216* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +tmp0=((T0*)(new254())); +r254make(((T254*)tmp0),INT32_C(0)); +/*SFN*/(C->_callbacks/*3p*/)=tmp0; +}/*--*/ + +/*SIGNAL_1[X_INPUT_DEVICE]*/void r216emit(T216* C,T0* a1){ +/*l43c5/signal_1.e*/ +/*SFN*/(C->_index/*3p*/)=INT32_C(0); +/*l44c5/signal_1.e*/ +/*SFN*/(C->_last/*3p*/)=(/*RF2*/((T254*)((/*RF2*/(C)->_callbacks/*3p*/)))->_upper/*3p*/); +while (!(((int32_t)((/*RF2*/(C)->_index/*3p*/)))>((/*RF2*/(C)->_last/*3p*/)))) +{ +/*l48c27/signal_1.e*/ +agent_launcher_X_INPUT_DEVICE(((/*RF2*/((T254*)((/*RF2*/(C)->_callbacks/*3p*/)))->_storage/*3p*/))[(/*RF2*/(C)->_index/*3p*/)],a1); +/*l49c5/signal_1.e*/ +/*SFN*/(C->_index/*3p*/)=((int32_t)((/*RF2*/(C)->_index/*3p*/)))+(INT32_C(1)); +} +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215put(T215* C,T2 a1,T2 a2){ +T2 _h=0; +T2 _idx=0; +T0* _node=(void*)0; +/*l139c4/hashed_dictionary.e*/ +/*l140c5/hashed_dictionary.e*/ +_h=(a2&/*0x7FFFFFFF*/INT32_C(2147483647)); +/*l141c5/hashed_dictionary.e*/ +_idx=((int32_t)(_h))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l142c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!((T6)(((_node)==((void*)((void*)0)))||((T6)(r215key_safe_equal((/*RF2*/(((T252*)_node))->_key/*3p*/),a2)))))) +{ +_node=(/*RF2*/(((T252*)_node))->_next/*3p*/); +} +/*l148c4/hashed_dictionary.e*/ +if((_node)==((void*)((void*)0))){ +/*l149c5/hashed_dictionary.e*/ +if(r215should_increase_capacity((/*RF2*/(C)->_capacity/*5p*/),(/*RF2*/(C)->_count/*5p*/))){ +/*l150c6/hashed_dictionary.e*/ +r215increase_capacity(C); +/*l151c6/hashed_dictionary.e*/ +_idx=((int32_t)(_h))%((/*RF2*/(C)->_capacity/*5p*/)); +} +/*l153c5/hashed_dictionary.e*/ +_node=r215new_node(C,a1,a2,((/*RF2*/(C)->_buckets/*5p*/))[_idx]); +/*l154c13/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node); +/*l155c5/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=((int32_t)((/*RF2*/(C)->_count/*5p*/)))+(INT32_C(1)); +/*l156c5/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +} +else{ +(/*RF2*/(((T252*)_node))->_item/*3p*/)=a1; +} +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215make(T215* C){ +r215create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215at(T215* C,T2 a1){ +T2 R=0; +T2 _idx=0; +T0* _node=(void*)0; +/*l59c4/hashed_dictionary.e*/ +/*l60c5/hashed_dictionary.e*/ +_idx=((int32_t)((a1&/*0x7FFFFFFF*/INT32_C(2147483647))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l61c5/hashed_dictionary.e*/ +_node=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +while (!(r215key_safe_equal((/*RF2*/(((T252*)_node))->_key/*3p*/),a1))) +{ +_node=(/*RF2*/(((T252*)_node))->_next/*3p*/); +} +/*l67c4/hashed_dictionary.e*/ +R=(/*RF2*/(((T252*)_node))->_item/*3p*/); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215prime_capacity(T2 a1){ +T2 R=0; +/*l138c4/hash_table_size.e*/ +R=(int32_t)(((uint32_t)(a1))+((uint32_t)(((int32_t)(a1))/(INT32_C(2))))); +/*l139c4/hash_table_size.e*/ +if(((int32_t)(R))>(INT32_C(0))){ +R=r215prime_number_ceiling(R); +} +else{ +R=r215prime_number_ceiling(INT32_C(2147483647)); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215prime_number_ceiling(T2 a1){ +T2 R=0; +if(((int32_t)(a1))<=(INT32_C(98317))){ +if(((int32_t)(a1))<=(INT32_C(769))){ +if(((int32_t)(a1))<=(INT32_C(53))){ +if(((int32_t)(a1))<=(INT32_C(11))){ +R=INT32_C(11); +} +else if(((int32_t)(a1))<=(INT32_C(23))){ +R=INT32_C(23); +} +else{ +R=INT32_C(53); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(193))){ +if(((int32_t)(a1))<=(INT32_C(97))){ +R=INT32_C(97); +} +else{ +R=INT32_C(193); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(389))){ +R=INT32_C(389); +} +else{ +R=INT32_C(769); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12289))){ +if(((int32_t)(a1))<=(INT32_C(3079))){ +if(((int32_t)(a1))<=(INT32_C(1543))){ +R=INT32_C(1543); +} +else{ +R=INT32_C(3079); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(6151))){ +R=INT32_C(6151); +} +else{ +R=INT32_C(12289); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(24593))){ +R=INT32_C(24593); +} +else if(((int32_t)(a1))<=(INT32_C(49157))){ +R=INT32_C(49157); +} +else{ +R=INT32_C(98317); +} +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(12582917))){ +if(((int32_t)(a1))<=(INT32_C(1572869))){ +if(((int32_t)(a1))<=(INT32_C(393241))){ +if(((int32_t)(a1))<=(INT32_C(196613))){ +R=INT32_C(196613); +} +else{ +R=INT32_C(393241); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(786433))){ +R=INT32_C(786433); +} +else{ +R=INT32_C(1572869); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(3145739))){ +R=INT32_C(3145739); +} +else if(((int32_t)(a1))<=(INT32_C(6291469))){ +R=INT32_C(6291469); +} +else{ +R=INT32_C(12582917); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(201326611))){ +if(((int32_t)(a1))<=(INT32_C(50331653))){ +if(((int32_t)(a1))<=(INT32_C(25165843))){ +R=INT32_C(25165843); +} +else{ +R=INT32_C(50331653); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(100663319))){ +R=INT32_C(100663319); +} +else{ +R=INT32_C(201326611); +} +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(805306457))){ +if(((int32_t)(a1))<=(INT32_C(402653189))){ +R=INT32_C(402653189); +} +else{ +R=INT32_C(805306457); +} +} +else{ +if(((int32_t)(a1))<=(INT32_C(1610612741))){ +R=INT32_C(1610612741); +} +else{ +R=INT32_C(2147483647); +} +} +} +} +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T6 r215should_increase_capacity(T2 a1,T2 a2){ +T6 R=0; +R=((T6)((T6)((((int32_t)(a2))>((int32_t)(((uint32_t)(((int32_t)(a1))/(INT32_C(3))))*((uint32_t)(INT32_C(2))))))&&((T6)(((int32_t)(a1))<(INT32_C(2147483647))))))); +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T6 r215key_safe_equal(T2 a1,T2 a2){ +T6 R=0; +if((a1)==(a2)){ +R=((T6)(1)); +} +else{ +R=((T6)((a1)==(a2))); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T0* r215common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T0* r215new_node(T215* C,T2 a1,T2 a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l519c4/hashed_dictionary.e*/ +R=(/*RF2*/((T253*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/); +/*l520c4/hashed_dictionary.e*/ +if((R)==((void*)((void*)0))){ +tmp0=((T0*)(new252())); +r252make(((T252*)tmp0),a1,a2,a3); +R=tmp0; +} +else{ +/*l29c4/weak_reference.e*/ +(/*RF2*/((T253*)((/*RF2*/(C)->_free_nodes/*5p*/)))->_item/*ip*/)=(/*RF2*/(((T252*)R))->_next/*3p*/); +/*l524c12/hashed_dictionary.e*/ +r252make(((T252*)R),a1,a2,a3); +} +return R; +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215create_with_capacity(T215* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r215common_free_nodes()),(T0*)(t[215])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new253())); +r253set_item(((T253*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r215common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[215])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new251(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215increase_capacity(T215* C){ +T2 _i=0; +T2 _idx=0; +T2 _new_capacity=0; +T251 _old_buckets=(void*)0; +T0* _node1=(void*)0; +T0* _node2=(void*)0; +/*l409c4/hashed_dictionary.e*/ +/*l410c5/hashed_dictionary.e*/ +_new_capacity=r215prime_capacity(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+(INT32_C(1))); +/*l411c5/hashed_dictionary.e*/ +_old_buckets=(/*RF2*/(C)->_buckets/*5p*/); +/*l412c5/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new251(_new_capacity); +/*l413c5/hashed_dictionary.e*/ +_i=((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1)); +/*l414c5/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=_new_capacity; +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l418c5/hashed_dictionary.e*/ +_node1=(_old_buckets)[_i]; +while (!((_node1)==((void*)((void*)0)))) +{ +/*l423c6/hashed_dictionary.e*/ +_node2=(/*RF2*/(((T252*)_node1))->_next/*3p*/); +/*l424c6/hashed_dictionary.e*/ +_idx=((int32_t)(((/*RF2*/(((T252*)_node1))->_key/*3p*/)&/*0x7FFFFFFF*/INT32_C(2147483647))))%((/*RF2*/(C)->_capacity/*5p*/)); +/*l31c4/hashed_dictionary_node.e*/ +(/*RF2*/(((T252*)_node1))->_next/*3p*/)=((/*RF2*/(C)->_buckets/*5p*/))[_idx]; +/*l426c14/hashed_dictionary.e*/ +((/*RF2*/(C)->_buckets/*5p*/))[_idx]=(_node1); +/*l427c6/hashed_dictionary.e*/ +_node1=_node2; +} +/*l429c5/hashed_dictionary.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l431c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213put(T213* C,T2 a1,T2 a2){ +((/*RF2*/(C)->_storage/*5p*/))[r213storage_index(C,a2)]=(a1); +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213clear_all(T213* C){ +T2 _value=0; +r213set_all_with(C,_value); +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213set_all_with(T213* C,T2 a1){ +T2 _s_u=0; +if(r213is_empty(C)){ +} +else{ +/*l241c5/ring_array.e*/ +_s_u=r213storage_upper(C); +/*l242c5/ring_array.e*/ +if(((int32_t)((/*RF2*/(C)->_storage_lower/*5p*/)))<=(_s_u)){ +r250set_slice_with((/*RF2*/(C)->_storage/*5p*/),a1,(/*RF2*/(C)->_storage_lower/*5p*/),_s_u); +} +else{ +/*l245c14/ring_array.e*/ +r250set_all_with((/*RF2*/(C)->_storage/*5p*/),a1,_s_u); +/*l246c14/ring_array.e*/ +r250set_slice_with((/*RF2*/(C)->_storage/*5p*/),a1,(/*RF2*/(C)->_storage_lower/*5p*/),((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(INT32_C(1))); +} +} +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T2 r213wrap_point(T213* C){ +T2 R=0; +R=((int32_t)(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))+((/*RF2*/(C)->_lower/*5p*/))))-((/*RF2*/(C)->_storage_lower/*5p*/)); +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213make_space_for_one(T213* C){ +T2 _old_capacity=0; +T2 _s_u=0; +T2 _wp=0; +if(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))<(((int32_t)(r213count(C)))+(INT32_C(1)))){ +if(((/*RF2*/(C)->_capacity/*5p*/))==(INT8_C(0))){ +/*l574c6/ring_array.e*/ +/*SFN*/(C->_capacity/*5p*/)=INT32_C(16); +/*l575c6/ring_array.e*/ +/*SFN*/(C->_storage/*5p*/)=new250((/*RF2*/(C)->_capacity/*5p*/)); +} +else{ +/*l577c6/ring_array.e*/ +_wp=r213wrap_point(C); +/*l578c6/ring_array.e*/ +_s_u=r213storage_upper(C); +/*l579c6/ring_array.e*/ +_old_capacity=(/*RF2*/(C)->_capacity/*5p*/); +/*l580c6/ring_array.e*/ +/*SFN*/(C->_capacity/*5p*/)=((int32_t)(INT32_C(2)))*((/*RF2*/(C)->_capacity/*5p*/)); +/*l581c6/ring_array.e*/ +/*SFN*/(C->_storage/*5p*/)=r250realloc((/*RF2*/(C)->_storage/*5p*/),_old_capacity,(/*RF2*/(C)->_capacity/*5p*/)); +/*l582c6/ring_array.e*/ +if(((int32_t)(_s_u))<((/*RF2*/(C)->_storage_lower/*5p*/))){ +/*l585c7/ring_array.e*/ +/*SFN*/(C->_upper/*5p*/)=((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*5p*/)))+((/*RF2*/(C)->_capacity/*5p*/))))-(_old_capacity); +/*l586c7/ring_array.e*/ +r213squeeze_bubble(C,(/*RF2*/(C)->_lower/*5p*/),(/*RF2*/(C)->_upper/*5p*/),_wp,((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))-(_old_capacity)); +/*l588c7/ring_array.e*/ +/*SFN*/(C->_upper/*5p*/)=((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*5p*/)))-((/*RF2*/(C)->_capacity/*5p*/))))+(_old_capacity); +} +} +} +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213squeeze_bubble(T213* C,T2 a1,T2 a2,T2 a3,T2 a4){ +if(((int32_t)(((int32_t)(a3))-(a1)))<=(((int32_t)(((int32_t)(a2))-(a3)))-(a4))){ +/*l621c5/ring_array.e*/ +r213move(C,a1,((int32_t)(a3))-(INT32_C(1)),a4); +/*l622c5/ring_array.e*/ +/*SFN*/(C->_storage_lower/*5p*/)=((int32_t)((/*RF2*/(C)->_storage_lower/*5p*/)))+(a4); +/*l623c5/ring_array.e*/ +if(((int32_t)((/*RF2*/(C)->_storage_lower/*5p*/)))>=((/*RF2*/(C)->_capacity/*5p*/))){ +/*SFN*/(C->_storage_lower/*5p*/)=((int32_t)((/*RF2*/(C)->_storage_lower/*5p*/)))-((/*RF2*/(C)->_capacity/*5p*/)); +} +} +else{ +r213move(C,((int32_t)(a3))+(a4),a2,-(a4)); +} +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T2 r213storage_upper(T213* C){ +T2 R=0; +R=r213storage_index(C,(/*RF2*/(C)->_upper/*5p*/)); +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T2 r213storage_index(T213* C,T2 a1){ +T2 R=0; +/*l728c4/ring_array.e*/ +R=((int32_t)(((int32_t)(a1))-((/*RF2*/(C)->_lower/*5p*/))))+((/*RF2*/(C)->_storage_lower/*5p*/)); +/*l729c4/ring_array.e*/ +if(((int32_t)(R))>=((/*RF2*/(C)->_capacity/*5p*/))){ +R=((int32_t)(R))-((/*RF2*/(C)->_capacity/*5p*/)); +} +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213make(T213* C,T2 a1,T2 a2){ +T2 _needed=0; +/*l44c4/ring_array.e*/ +/*SFN*/(C->_lower/*5p*/)=a1; +/*l45c4/ring_array.e*/ +/*SFN*/(C->_upper/*5p*/)=a2; +/*l46c4/ring_array.e*/ +_needed=((int32_t)(((int32_t)(a2))-(a1)))+(INT32_C(1)); +/*l47c4/ring_array.e*/ +/*SFN*/(C->_storage_lower/*5p*/)=INT32_C(0); +/*l48c4/ring_array.e*/ +if(((int32_t)(_needed))>(INT32_C(0))){ +if(((int32_t)((/*RF2*/(C)->_capacity/*5p*/)))<(_needed)){ +/*l50c6/ring_array.e*/ +/*SFN*/(C->_storage/*5p*/)=new250(_needed); +/*l51c6/ring_array.e*/ +/*SFN*/(C->_capacity/*5p*/)=_needed; +} +else{ +r213clear_all(C); +} +} +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213add_last(T213* C,T2 a1){ +/*l324c4/ring_array.e*/ +r213make_space_for_one(C); +/*l325c4/ring_array.e*/ +/*SFN*/(C->_upper/*5p*/)=((int32_t)((/*RF2*/(C)->_upper/*5p*/)))+(INT32_C(1)); +/*l326c4/ring_array.e*/ +r213put(C,a1,(/*RF2*/(C)->_upper/*5p*/)); +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T2 r213count(T213* C){ +T2 R=0; +R=((int32_t)(((int32_t)((/*RF2*/(C)->_upper/*5p*/)))-((/*RF2*/(C)->_lower/*5p*/))))+(INT32_C(1)); +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T6 r213is_empty(T213* C){ +T6 R=0; +R=((T6)(((int32_t)((/*RF2*/(C)->_upper/*5p*/)))<((/*RF2*/(C)->_lower/*5p*/)))); +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/T2 r213item(T213* C,T2 a1){ +T2 R=0; +R=((/*RF2*/(C)->_storage/*5p*/))[r213storage_index(C,a1)]; +return R; +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213remove_first(T213* C){ +/*l253c4/ring_array.e*/ +/*SFN*/(C->_lower/*5p*/)=((int32_t)((/*RF2*/(C)->_lower/*5p*/)))+(INT32_C(1)); +/*l254c4/ring_array.e*/ +/*SFN*/(C->_storage_lower/*5p*/)=((int32_t)((/*RF2*/(C)->_storage_lower/*5p*/)))+(INT32_C(1)); +/*l255c4/ring_array.e*/ +if(((/*RF2*/(C)->_storage_lower/*5p*/))==((/*RF2*/(C)->_capacity/*5p*/))){ +/*SFN*/(C->_storage_lower/*5p*/)=INT32_C(0); +} +}/*--*/ + +/*RING_ARRAY[INTEGER_32]*/void r213move(T213* C,T2 a1,T2 a2,T2 a3){ +T2 _default_value=0; +T2 _i=0; +if((a3)==(INT8_C(0))){ +} +else if(((int32_t)(a3))<(INT32_C(0))){ +_i=a1; +while (!(((int32_t)(_i))>(a2))) +{ +/*l616c6/collection.e*/ +r213put(C,r213item(C,_i),((int32_t)(_i))+(a3)); +/*l617c6/collection.e*/ +r213put(C,_default_value,_i); +/*l618c6/collection.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +else{ +_i=a2; +while (!(((int32_t)(_i))<(a1))) +{ +/*l626c6/collection.e*/ +r213put(C,r213item(C,_i),((int32_t)(_i))+(a3)); +/*l627c6/collection.e*/ +r213put(C,_default_value,_i); +/*l628c6/collection.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +} +}/*--*/ + +/*HASHED_DICTIONARY[POINTER,STRING]*/void r211make(T211* C){ +r211create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[POINTER,STRING]*/T0* r211common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[POINTER,STRING]*/void r211create_with_capacity(T211* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r211common_free_nodes()),(T0*)(t[211])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new249())); +r249set_item(((T249*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r211common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[211])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new247(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/void r208make(T208* C){ +r208create_with_capacity(C,INT32_C(53)); +}/*--*/ + +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/T0* r208common_free_nodes(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _fn=(void*)0; +if(fBC136common_free_nodes==0){fBC136common_free_nodes=1;{ +/*l499c4/hashed_dictionary.e*/ +tmp0=((T0*)(new245())); +r245set_item(((T245*)tmp0),(void*)0); +_fn=tmp0; +/*l500c4/hashed_dictionary.e*/ +tmp0=((T0*)(new244())); +r244special_common_dictionary(((T244*)tmp0),_fn); +oBC136common_free_nodes=tmp0; +/*l501c11/hashed_dictionary.e*/ +r244add(((T244*)oBC136common_free_nodes),_fn,(T0*)(t[244])); +}} +return oBC136common_free_nodes; +}/*--*/ + +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/void r208create_with_capacity(T208* C,T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l532c4/hashed_dictionary.e*/ +/*SFN*/(C->_free_nodes/*5p*/)=r244fast_reference_at((T244*)(r208common_free_nodes()),(T0*)(t[208])); +/*l533c4/hashed_dictionary.e*/ +if(((/*RF2*/(C)->_free_nodes/*5p*/))==((void*)((void*)0))){ +/*l534c5/hashed_dictionary.e*/ +tmp0=((T0*)(new243())); +r243set_item(((T243*)tmp0),(void*)0); +/*SFN*/(C->_free_nodes/*5p*/)=tmp0; +/*l535c23/hashed_dictionary.e*/ +r244add((T244*)(r208common_free_nodes()),(/*RF2*/(C)->_free_nodes/*5p*/),(T0*)(t[208])); +} +/*l537c4/hashed_dictionary.e*/ +/*SFN*/(C->_buckets/*5p*/)=new239(a1); +/*l538c4/hashed_dictionary.e*/ +/*SFN*/(C->_capacity/*5p*/)=a1; +/*l539c4/hashed_dictionary.e*/ +/*SFN*/(C->_cache_user/*5p*/)=INT32_C(-1); +/*l540c4/hashed_dictionary.e*/ +/*SFN*/(C->_count/*5p*/)=INT32_C(0); +}/*--*/ + +/*STREAM_EXCEPTION*/void r110expect(T110* C,T0* a1){ +r147when_exception(((T147*)a1),(/*RF2*/(C)->_stream/*ip*/)); +}/*--*/ + +/*STREAM_EXCEPTION*/T6 r110occurred(T110* C,T0* a1){ +T6 R=0; +R=((T6)(r147is_exception(((T147*)a1),(/*RF2*/(C)->_stream/*ip*/)))); +return R; +}/*--*/ + +/*STREAM_EXCEPTION*/void r110make(T110* C,T0* a1){ +/*SFN*/(C->_stream/*ip*/)=a1; +}/*--*/ + +/*CAN_READ_DATA_FROM_STREAM*/void r120expect(T120* C,T0* a1){ +r147when_data(((T147*)a1),(/*RF2*/(C)->_input_stream/*ip*/)); +}/*--*/ + +/*CAN_READ_DATA_FROM_STREAM*/T6 r120occurred(T120* C,T0* a1){ +T6 R=0; +R=((T6)(r147is_data(((T147*)a1),(/*RF2*/(C)->_input_stream/*ip*/)))); +return R; +}/*--*/ + +/*CAN_READ_DATA_FROM_STREAM*/void r120make(T120* C,T0* a1){ +/*SFN*/(C->_input_stream/*ip*/)=a1; +}/*--*/ + +/*TIME*/T6 r189_ix_60(T189* C,T189 a1){ +T6 R=0; +R=((T6)((time_difftime((/*RF2*/(a1)._time_memory/**/),(/*RF2*/(*C)._time_memory/**/)))>(/*IC*/(T5)(INT8_C(0))))); +return R; +}/*--*/ + +/*TIME*/T5 r189elapsed_seconds(T189* C,T189 a1){ +T5 R=0; +R=time_difftime((/*RF2*/(a1)._time_memory/**/),(/*RF2*/(*C)._time_memory/**/)); +return R; +}/*--*/ + +/*MICROSECOND_TIME*/T6 r176_ix_60(T176* C,T176 a1){ +T6 R=0; +R=((T6)((T6)((r189_ix_60(&((/*RF2*/(*C)._time/**/)),(/*RF2*/(a1)._time/**/)))||((T6)((T6)((!se_cmpT189(((/*RF2*/(*C)._time/**/)),((/*RF2*/(a1)._time/**/))))&&((T6)(((int32_t)((/*RF2*/(*C)._microsecond/**/)))<((/*RF2*/(a1)._microsecond/**/)))))))))); +return R; +}/*--*/ + +/*MICROSECOND_TIME*/T5 r176elapsed_seconds(T176* C,T176 a1){ +T5 R=0; +/*l101c4/microsecond_time.e*/ +R=r189elapsed_seconds(&((/*RF2*/(*C)._time/**/)),(/*RF2*/(a1)._time/**/)); +/*l102c4/microsecond_time.e*/ +R=(R)+(((T5)(((int32_t)((/*RF2*/(a1)._microsecond/**/)))-((/*RF2*/(*C)._microsecond/**/))))/(INT32_C(1000000))); +return R; +}/*--*/ + +/*MICROSECOND_TIME*/void r176update(T176* C){ +/*l25c4/microsecond_time.e*/ +basic_microsecond_update; +/*l222c4/time.e*/ +(/*RF2*/((/*RF2*/(*C)._time/**/))._time_memory/**/)=basic_microsecond_time; +/*l27c4/microsecond_time.e*/ +/*SFN*/(C->_microsecond/**/)=basic_microsecond_microsecond; +}/*--*/ + +/*EVENTS_SET*/void r147reset(T147* C){ +/*l62c4/events_set.e*/ +/*SFN*/(C->_timeout/*12p*/)=INT32_C(2147483647); +/*l63c4/events_set.e*/ +/*SFN*/(C->_expiration_valid/*12p*/)=((T6)(0)); +/*l64c4/events_set.e*/ +/*SFN*/(C->_current_time_valid/*12p*/)=((T6)(0)); +/*l65c4/events_set.e*/ +sequencer_reset((/*RF2*/(C)->_read_set/*12p*/)); +/*l66c4/events_set.e*/ +sequencer_reset((/*RF2*/(C)->_write_set/*12p*/)); +/*l67c4/events_set.e*/ +sequencer_reset((/*RF2*/(C)->_exception_set/*12p*/)); +/*l68c4/events_set.e*/ +/*SFN*/(C->_highest/*12p*/)=INT32_C(-1); +/*l69c4/events_set.e*/ +/*SFN*/(C->_read_size/*12p*/)=INT32_C(0); +/*l70c4/events_set.e*/ +/*SFN*/(C->_write_size/*12p*/)=INT32_C(0); +/*l71c4/events_set.e*/ +/*SFN*/(C->_exception_size/*12p*/)=INT32_C(0); +/*l72c4/events_set.e*/ +/*SFN*/(C->_queryable/*12p*/)=((T6)(0)); +}/*--*/ + +/*EVENTS_SET*/void r147expect(T147* C,T0* a1){ +X109expect(a1,(T0*)C); +}/*--*/ + +/*EVENTS_SET*/void r147make(T147* C){ +/*l37c4/events_set.e*/ +/*SFN*/(C->_read_set/*12p*/)=sequencer_create_set; +/*l38c4/events_set.e*/ +/*SFN*/(C->_write_set/*12p*/)=sequencer_create_set; +/*l39c4/events_set.e*/ +/*SFN*/(C->_exception_set/*12p*/)=sequencer_create_set; +/*l40c4/events_set.e*/ +r147reset(C); +}/*--*/ + +/*EVENTS_SET*/void r147when_data(T147* C,T0* a1){ +/*l165c4/events_set.e*/ +sequencer_watch((/*RF2*/(C)->_read_set/*12p*/),X49descriptor(a1)); +/*l166c4/events_set.e*/ +/*SFN*/(C->_read_size/*12p*/)=((int32_t)((/*RF2*/(C)->_read_size/*12p*/)))+(INT32_C(1)); +/*l167c4/events_set.e*/ +/*SFN*/(C->_highest/*12p*/)=r2max((/*RF2*/(C)->_highest/*12p*/),X49descriptor(a1)); +}/*--*/ + +/*EVENTS_SET*/T6 r147is_data(T147* C,T0* a1){ +T6 R=0; +R=((T6)(sequencer_is_ready((/*RF2*/(C)->_read_set/*12p*/),X49descriptor(a1)))); +return R; +}/*--*/ + +/*EVENTS_SET*/void r147when_exception(T147* C,T0* a1){ +/*l227c5/events_set.e*/ +sequencer_watch((/*RF2*/(C)->_exception_set/*12p*/),r146descriptor(((T146*)a1))); +/*l228c5/events_set.e*/ +/*SFN*/(C->_exception_size/*12p*/)=((int32_t)((/*RF2*/(C)->_exception_size/*12p*/)))+(INT32_C(1)); +/*l229c5/events_set.e*/ +/*SFN*/(C->_highest/*12p*/)=r2max((/*RF2*/(C)->_highest/*12p*/),r146descriptor(((T146*)a1))); +}/*--*/ + +/*EVENTS_SET*/T6 r147event_occurred(T147* C,T0* a1){ +T6 R=0; +R=((T6)(X109occurred(a1,(T0*)C))); +return R; +}/*--*/ + +/*EVENTS_SET*/T6 r147is_exception(T147* C,T0* a1){ +T6 R=0; +R=((T6)(sequencer_is_ready((/*RF2*/(C)->_exception_set/*12p*/),r146descriptor(((T146*)a1))))); +return R; +}/*--*/ + +/*EVENTS_SET*/void r147wait(T147* C){ +T176 _now={{0},0}; +T2 _s=0; +T2 _us=0; +T5 _remaining=0; +/*l89c4/events_set.e*/ +if((/*RF2*/(C)->_expiration_valid/*12p*/)){ +/*l90c9/events_set.e*/ +r176update(&_now); +/*l91c5/events_set.e*/ +if(r176_ix_60(&_now,(/*RF2*/(C)->_expiration/*12p*/))){ +_remaining=r176elapsed_seconds(&_now,(/*RF2*/(C)->_expiration/*12p*/)); +} +/*l94c5/events_set.e*/ +if((((T5)((/*RF2*/(C)->_timeout/*12p*/)))/(INT32_C(1000)))<(_remaining)){ +_remaining=((T5)((/*RF2*/(C)->_timeout/*12p*/)))/(INT32_C(1000)); +} +} +else{ +_remaining=((T5)((/*RF2*/(C)->_timeout/*12p*/)))/(INT32_C(1000)); +} +/*l100c4/events_set.e*/ +/*l101c5/events_set.e*/ +_s=((int32_t)(floor(_remaining))); +/*l102c5/events_set.e*/ +_us=((int32_t)(floor(((_remaining)-(/*IC*/(T5)(_s)))*(/*IC*/(T5)(INT32_C(1000000)))))); +while (!((sequencer_wait(((int32_t)((/*RF2*/(C)->_highest/*12p*/)))+(INT32_C(1)),(/*RF2*/(C)->_read_set/*12p*/),(/*RF2*/(C)->_read_size/*12p*/),(/*RF2*/(C)->_write_set/*12p*/),(/*RF2*/(C)->_write_size/*12p*/),(/*RF2*/(C)->_exception_set/*12p*/),(/*RF2*/(C)->_exception_size/*12p*/),_s,_us))!=(INT8_C(-1)))) +{ +} +/*l107c4/events_set.e*/ +/*SFN*/(C->_queryable/*12p*/)=((T6)(1)); +/*l108c4/events_set.e*/ +/*SFN*/(C->_current_time_valid/*12p*/)=((T6)(0)); +}/*--*/ + +/*ROOT_LAYOUT*/void r158set_container(T158* C,T0* a1){ +/*SFN*/(C->_container/*p*/)=a1; +}/*--*/ + +/*STD_INPUT*/void r54make(T54* C){ +/*l43c4/std_input.e*/ +/*SFN*/(C->_buffer/*3p*/)=new9(INT32_C(4096)); +/*l44c4/std_input.e*/ +/*SFN*/(C->_capacity/*3p*/)=INT32_C(4096); +}/*--*/ + +/*STD_INPUT*/void r54dispose(T54* C){ +(/*RF2*/(C)->_filter/*3p*/)=(void*)0; +}/*--*/ + +/*KEY_RANGE*/void r139make(T139* C,T8 a1){ +x_key_info_init(a1,/*$*/((void*)&(C->_minimum_code)),/*$*/((void*)&(C->_maximum_code)),/*$*/((void*)&(C->_key_count))); +}/*--*/ + +/*BUTTON_RANGE*/void r142make(T142* C,T8 a1){ +/*SFN*/(C->_buttons_count/*p*/)=x_button_info_num_buttons(a1); +}/*--*/ + +/*AXES_RANGE*/void r141make(T141* C,T8 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _nb_axes=0; +/*l11c4/axes_range.e*/ +x_valuator_info_init(a1,/*$*/&_nb_axes,/*$*/((void*)&(C->_absolute)),/*$*/((void*)&(C->_motion_buffer_size))); +/*l12c4/axes_range.e*/ +tmp0=((T0*)(new214())); +r214make(((T214*)tmp0),_nb_axes); +/*SFN*/(C->_minimums/*5p*/)=tmp0; +/*l13c4/axes_range.e*/ +tmp0=((T0*)(new214())); +r214make(((T214*)tmp0),_nb_axes); +/*SFN*/(C->_maximums/*5p*/)=tmp0; +/*l14c4/axes_range.e*/ +tmp0=((T0*)(new214())); +r214make(((T214*)tmp0),_nb_axes); +/*SFN*/(C->_resolutions/*5p*/)=tmp0; +/*l15c4/axes_range.e*/ +_nb_axes=((int32_t)(_nb_axes))-(INT32_C(1)); +while (!(((int32_t)(_nb_axes))<(INT32_C(0)))) +{ +/*l122c12/fast_array.e*/ +((/*RF2*/((T214*)((/*RF2*/(C)->_resolutions/*5p*/)))->_storage/*3p*/))[_nb_axes]=(x_valuator_info_resolution(a1,_nb_axes)); +/*l122c12/fast_array.e*/ +((/*RF2*/((T214*)((/*RF2*/(C)->_minimums/*5p*/)))->_storage/*3p*/))[_nb_axes]=(x_valuator_info_minimum(a1,_nb_axes)); +/*l122c12/fast_array.e*/ +((/*RF2*/((T214*)((/*RF2*/(C)->_maximums/*5p*/)))->_storage/*3p*/))[_nb_axes]=(x_valuator_info_maximum(a1,_nb_axes)); +/*l23c5/axes_range.e*/ +_nb_axes=((int32_t)(_nb_axes))-(INT32_C(1)); +} +}/*--*/ + +/*IVY_CLIENT*/T2 r146descriptor(T146* C){ +T2 R=0; +R=(/*RF2*/(C)->_filtered_descriptor/*i7p*/); +return R; +}/*--*/ + +/*IVY_CLIENT*/T0* r146event_can_read(T146* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l143c4/input_stream.e*/ +R=(/*RF2*/(C)->_can_read/*i7p*/); +/*l144c4/input_stream.e*/ +if((R)==((void*)((void*)0))){ +/*l145c5/input_stream.e*/ +tmp0=((T0*)(new120())); +r120make(((T120*)tmp0),(T0*)C); +/*SFN*/(C->_can_read/*i7p*/)=tmp0; +/*l146c5/input_stream.e*/ +R=(/*RF2*/(C)->_can_read/*i7p*/); +} +return R; +}/*--*/ + +/*IVY_CLIENT*/void r146make(T146* C,T2 a1,T8 a2,T8 a3,T8 a4){ +/*l14c4/ivy_client.e*/ +/*SFN*/(C->_filtered_descriptor/*i7p*/)=a1; +/*l15c4/ivy_client.e*/ +/*SFN*/(C->_data/*i7p*/)=a2; +/*l16c4/ivy_client.e*/ +/*SFN*/(C->_read_function/*i7p*/)=a3; +/*l17c4/ivy_client.e*/ +/*SFN*/(C->_delete_function/*i7p*/)=a4; +/*l18c4/ivy_client.e*/ +/*SFN*/(C->_is_connected/*i7p*/)=((T6)(1)); +}/*--*/ + +/*IVY_CLIENT*/void r146process_incomming_data(T146* C){ +read_callback((/*RF2*/(C)->_read_function/*i7p*/),(T0*)C,(/*RF2*/(C)->_filtered_descriptor/*i7p*/),(/*RF2*/(C)->_data/*i7p*/)); +}/*--*/ + +/*IVY_CLIENT*/void r146disconnect(T146* C){ +if((NULL!=(/*RF2*/(C)->_delete_function/*i7p*/))){ +delete_callback((/*RF2*/(C)->_delete_function/*i7p*/),(/*RF2*/(C)->_data/*i7p*/)); +} +}/*--*/ + +/*IVY_CLIENT*/void r146dispose(T146* C){ +if((/*RF2*/(C)->_is_connected/*i7p*/)){ +r146disconnect(C); +} +}/*--*/ + +/*IVY_CLIENT*/T0* r146event_exception(T146* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l113c4/stream.e*/ +R=(/*RF2*/(C)->_stream_exception/*i7p*/); +/*l114c4/stream.e*/ +if((R)==((void*)((void*)0))){ +/*l115c5/stream.e*/ +tmp0=((T0*)(new110())); +r110make(((T110*)tmp0),(T0*)C); +/*SFN*/(C->_stream_exception/*i7p*/)=tmp0; +/*l116c5/stream.e*/ +R=(/*RF2*/(C)->_stream_exception/*i7p*/); +} +return R; +}/*--*/ + +T148*create148make(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +tmp0=((T0*)(new148())); +r148make(((T148*)tmp0)); +return ((T148*)tmp0); +}/*--*/ + +/*LOOP_ITEM*/void r148add_job(T148* C,T0* a1){ +T2 _i=0; +/*l136c4/loop_item.e*/ +_i=INT32_C(0); +while (!((T6)((((int32_t)(_i))>((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_upper/*3p*/)))||((T6)(((int32_t)(X71priority(((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_storage/*3p*/))[_i])))>(X71priority(a1))))))) +{ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l143c13/loop_item.e*/ +r236add((T236*)((/*RF2*/(C)->_job_list/*6p*/)),a1,_i); +}/*--*/ + +/*LOOP_ITEM*/void r148run(T148* C){ +T2 _i=0; +T2 _selected_priority=0; +T0* _job=(void*)0; +/*l48c5/loop_item.e*/ +/*SFN*/(C->_pause/*6p*/)=((T6)(0)); +/*l49c5/loop_item.e*/ +/*SFN*/(C->_break/*6p*/)=((T6)(0)); +while (!((T6)(((T6)(((/*RF2*/(C)->_pause/*6p*/))||((T6)((/*RF2*/(C)->_break/*6p*/)))))||((T6)(r236is_empty((T236*)((/*RF2*/(C)->_job_list/*6p*/)))))))) +{ +/*l54c5/loop_item.e*/ +/*l55c6/loop_item.e*/ +_i=INT32_C(0); +/*l56c13/loop_item.e*/ +r147reset((T147*)((/*RF2*/(C)->_events/*6p*/))); +while (!(((int32_t)(_i))>((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_upper/*3p*/)))) +{ +/*l62c6/loop_item.e*/ +_job=((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_storage/*3p*/))[_i]; +/*l63c6/loop_item.e*/ +if(X71done(_job)){ +/*l64c16/loop_item.e*/ +r236remove((T236*)((/*RF2*/(C)->_job_list/*6p*/)),_i); +/*l65c21/loop_item.e*/ +r236add_last((T236*)((/*RF2*/(C)->_finished_jobs/*6p*/)),_job); +} +else{ +/*l67c11/loop_item.e*/ +X71prepare(_job,(/*RF2*/(C)->_events/*6p*/)); +/*l68c7/loop_item.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +/*l71c5/loop_item.e*/ +if((r236is_empty((T236*)((/*RF2*/(C)->_job_list/*6p*/))))==(0)){ +/*l73c13/loop_item.e*/ +r147wait((T147*)((/*RF2*/(C)->_events/*6p*/))); +/*l75c6/loop_item.e*/ +/*l76c7/loop_item.e*/ +_i=INT32_C(0); +/*l77c7/loop_item.e*/ +_selected_priority=INT32_MIN; +/*l163c4/fast_array.e*/ +(/*RF2*/((T236*)((/*RF2*/(C)->_ready_jobs/*6p*/)))->_upper/*3p*/)=INT32_C(-1); +while (!((T6)((((int32_t)(_i))>((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_upper/*3p*/)))||((T6)((_selected_priority)!=(INT32_MIN)))))) +{ +/*l82c7/loop_item.e*/ +_job=((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_storage/*3p*/))[_i]; +/*l83c7/loop_item.e*/ +if(X71is_ready(_job,(/*RF2*/(C)->_events/*6p*/))){ +/*l84c8/loop_item.e*/ +_selected_priority=X71priority(_job); +/*l85c19/loop_item.e*/ +r236add_last((T236*)((/*RF2*/(C)->_ready_jobs/*6p*/)),_job); +} +/*l87c7/loop_item.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l89c6/loop_item.e*/ +while (!((T6)((((int32_t)(_i))>((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_upper/*3p*/)))||((T6)((X71priority(((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_storage/*3p*/))[_i]))!=(_selected_priority)))))) +{ +/*l93c7/loop_item.e*/ +_job=((/*RF2*/((T236*)((/*RF2*/(C)->_job_list/*6p*/)))->_storage/*3p*/))[_i]; +/*l94c7/loop_item.e*/ +if(X71is_ready(_job,(/*RF2*/(C)->_events/*6p*/))){ +r236add_last((T236*)((/*RF2*/(C)->_ready_jobs/*6p*/)),_job); +} +/*l97c7/loop_item.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l100c6/loop_item.e*/ +_i=(/*RF2*/((T236*)((/*RF2*/(C)->_ready_jobs/*6p*/)))->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l105c26/loop_item.e*/ +X71continue(((/*RF2*/((T236*)((/*RF2*/(C)->_ready_jobs/*6p*/)))->_storage/*3p*/))[_i]); +/*l106c7/loop_item.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +} +} +}/*--*/ + +/*LOOP_ITEM*/void r148make(T148* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l25c4/loop_item.e*/ +tmp0=((T0*)(new236())); +r236make(((T236*)tmp0),INT32_C(0)); +/*SFN*/(C->_job_list/*6p*/)=tmp0; +/*l26c4/loop_item.e*/ +tmp0=((T0*)(new236())); +r236make(((T236*)tmp0),INT32_C(0)); +/*SFN*/(C->_finished_jobs/*6p*/)=tmp0; +/*l27c4/loop_item.e*/ +tmp0=((T0*)(new236())); +r236make(((T236*)tmp0),INT32_C(0)); +/*SFN*/(C->_ready_jobs/*6p*/)=tmp0; +/*l28c4/loop_item.e*/ +tmp0=((T0*)(new147())); +r147make(((T147*)tmp0)); +/*SFN*/(C->_events/*6p*/)=tmp0; +/*l29c4/loop_item.e*/ +/*SFN*/(C->_pause/*6p*/)=((T6)(1)); +}/*--*/ + +/*GRAPHIC_CONNECTION*/T0* r131event_can_read(T131* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l143c4/input_stream.e*/ +R=(/*RF2*/(C)->_can_read/*i2p*/); +/*l144c4/input_stream.e*/ +if((R)==((void*)((void*)0))){ +/*l145c5/input_stream.e*/ +tmp0=((T0*)(new120())); +r120make(((T120*)tmp0),(T0*)C); +/*SFN*/(C->_can_read/*i2p*/)=tmp0; +/*l146c5/input_stream.e*/ +R=(/*RF2*/(C)->_can_read/*i2p*/); +} +return R; +}/*--*/ + +/*GRAPHIC_CONNECTION*/void r131set_descriptor(T131* C,T2 a1){ +/*SFN*/(C->_descriptor/*i2p*/)=a1; +}/*--*/ + +/*GRAPHIC_CONNECTION*/T2 r131filtered_descriptor(T131* C){ +T2 R=0; +R=(/*RF2*/(C)->_descriptor/*i2p*/); +return R; +}/*--*/ + +/*GRAPHIC_CONNECTION*/void r131dispose(T131* C){ +if(((/*RF2*/(C)->_descriptor/*i2p*/))!=(INT8_C(0))){ +} +}/*--*/ + +/*VISION_LOOP_STACK*/T0* r130current_loop(T130* C){ +T0* R=(void*)0; +if((r206is_empty((T206*)((/*RF2*/(C)->_loop_stack/*4p*/))))==(0)){ +R=r206last((T206*)((/*RF2*/(C)->_loop_stack/*4p*/))); +} +return R; +}/*--*/ + +/*VISION_LOOP_STACK*/void r130add_job(T130* C,T0* a1){ +r148add_job((T148*)(r130current_loop(C)),a1); +}/*--*/ + +/*VISION_LOOP_STACK*/void r130run(T130* C){ +/*SFN*/(C->_stop/*4p*/)=((T6)(0)); +while (!((T6)(((/*RF2*/(C)->_stop/*4p*/))||((T6)(r206is_empty((T206*)((/*RF2*/(C)->_loop_stack/*4p*/)))))))) +{ +/*l61c18/loop_stack.e*/ +r148run((T148*)(r130current_loop(C))); +/*l62c5/loop_stack.e*/ +if((r130current_loop(C))!=((void*)((void*)0))){ +if(((/*RF2*/((T148*)(r130current_loop(C)))->_pause/*6p*/))==(0)){ +r206remove_last((T206*)((/*RF2*/(C)->_loop_stack/*4p*/))); +} +} +} +}/*--*/ + +/*VISION_LOOP_STACK*/void r130make(T130* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l20c4/vision_loop_stack.e*/ +r130_P_129_make(C); +/*l21c4/vision_loop_stack.e*/ +tmp0=((T0*)(new235())); +r235make(((T235*)tmp0),INT32_C(0)); +/*SFN*/(C->_event_catcher_stack/*4p*/)=tmp0; +}/*--*/ + +/*VISION_LOOP_STACK*/void r130_P_129_make(T130* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l16c4/loop_stack.e*/ +tmp0=((T0*)(new206())); +r206make(((T206*)tmp0),INT32_C(0)); +/*SFN*/(C->_loop_stack/*4p*/)=tmp0; +/*l17c15/loop_stack.e*/ +r206add_last((T206*)((/*RF2*/(C)->_loop_stack/*4p*/)),((T0*)create148make())); +}/*--*/ + +/*EVENT_CATCHER*/void r128add_extension(T128* C,T0* a1){ +r226put((T226*)((/*RF2*/(C)->_extension_devices/*i11p*/)),a1,(/*RF2*/(((T67*)a1))->_device_id/*14p*/)); +}/*--*/ + +/*EVENT_CATCHER*/T0* r128search_widget(T128* C,T8 a1){ +T0* R=(void*)0; +T0* _stack=(void*)0; +T0* _ls=(void*)0; +T2 _i=0; +/*l264c4/event_catcher.e*/ +/*l265c5/event_catcher.e*/ +_ls=(/*RF2*/((T64*)(r128vision()))->_loop_stack/*6p*/); +/*l266c5/event_catcher.e*/ +_stack=(/*RF2*/(((T130*)_ls))->_event_catcher_stack/*4p*/); +/*l267c5/event_catcher.e*/ +_i=(/*RF2*/(((T235*)_stack))->_upper/*3p*/); +while (!((T6)(((R)!=((void*)((void*)0)))||((T6)(((int32_t)(_i))<(INT32_C(0))))))) +{ +/*l271c5/event_catcher.e*/ +R=r227reference_at((T227*)((/*RF2*/((T128*)(((/*RF2*/(((T235*)_stack))->_storage/*3p*/))[_i]))->_widget/*i11p*/)),a1); +/*l272c5/event_catcher.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l274c4/event_catcher.e*/ +if((R)!=((void*)((void*)0))){ +/*SFN*/(C->_event_catcher_found/*i11p*/)=((/*RF2*/(((T235*)_stack))->_storage/*3p*/))[((int32_t)(_i))+(INT32_C(1))]; +} +return R; +}/*--*/ + +/*EVENT_CATCHER*/void r128prepare(T128* C,T0* a1){ +/*l94c4/event_catcher.e*/ +basic_vision_flush; +/*l95c11/event_catcher.e*/ +r147expect(((T147*)a1),r131event_can_read((T131*)((/*RF2*/(C)->_graphic_connection/*i11p*/)))); +}/*--*/ +/*l161c6/event_catcher.e*//*l169c7/event_catcher.e*//*l174c7/event_catcher.e*//*l183c7/event_catcher.e*//*l192c7/event_catcher.e*/ +/*EVENT_CATCHER*/void r128emit_event(T128* C,T0* a1,T2 a2){ +T0* _sig0=(void*)0; +T0* _sig2=(void*)0; +T0* _sig4=(void*)0; +T0* _win=(void*)0; +T0* _ext_device=(void*)0; +if(((int32_t)(a2))<(INT32_C(100))){ +/*l159c5/event_catcher.e*/ +_sig0=r234reference_at((T234*)(((/*RF2*/((T232*)((/*RF2*/(C)->_event/*i11p*/)))->_storage/*3p*/))[a2]),a1); +/*l160c5/event_catcher.e*/ +if((_sig0)!=((void*)((void*)0))){ +/*se_evobt*/_sig0,se_print_run_time_stack(),exit(1); +} +} +else{ +/*[INSPECT*/ +{int inspect_tmp_1=a2; +switch(inspect_tmp_1){ +case 100: +/*l167c6/event_catcher.e*/ +_sig2=r230reference_at((T230*)((/*RF2*/(C)->_pointer_move_event/*i11p*/)),a1); +/*l168c6/event_catcher.e*/ +if((_sig2)!=((void*)((void*)0))){ +/*se_evobt*/_sig2,se_print_run_time_stack(),exit(1); +} +break; +case 101: +/*l172c6/event_catcher.e*/ +_sig4=r228reference_at((T228*)((/*RF2*/(C)->_geometry_change_event/*i11p*/)),a1); +/*l173c6/event_catcher.e*/ +if((_sig4)!=((void*)((void*)0))){ +/*se_evobt*/_sig4,se_print_run_time_stack(),exit(1); +} +break; +case 102: +/*l177c6/event_catcher.e*/ +_sig4=r228reference_at((T228*)((/*RF2*/(C)->_geometry_change_event/*i11p*/)),a1); +/*l178c6/event_catcher.e*/ +if((_sig4)!=((void*)((void*)0))){ +/*l179c7/event_catcher.e*/ +_win=a1; +/*l183c12/event_catcher.e*/ +/*se_evobt*/_sig4,se_print_run_time_stack(),exit(1); +} +break; +case 103: +/*l186c6/event_catcher.e*/ +_sig4=r228reference_at((T228*)((/*RF2*/(C)->_geometry_change_event/*i11p*/)),a1); +/*l187c6/event_catcher.e*/ +if((_sig4)!=((void*)((void*)0))){ +/*l188c7/event_catcher.e*/ +_win=a1; +/*l192c12/event_catcher.e*/ +/*se_evobt*/_sig4,se_print_run_time_stack(),exit(1); +} +break; +default:; +/*l195c6/event_catcher.e*/ +_ext_device=r226reference_at((T226*)((/*RF2*/(C)->_extension_devices/*i11p*/)),basic_vision_extension_device_id); +/*l196c6/event_catcher.e*/ +if((_ext_device)!=((void*)((void*)0))){ +r67handle_event(((T67*)_ext_device),basic_vision_real_event,a1); +} +} +}/*INSPECT]*/ +} +}/*--*/ + +/*EVENT_CATCHER*/T6 r128is_ready(T128* C,T0* a1){ +T6 R=0; +R=((T6)(r147event_occurred(((T147*)a1),r131event_can_read((T131*)((/*RF2*/(C)->_graphic_connection/*i11p*/)))))); +return R; +}/*--*/ + +/*EVENT_CATCHER*/void r128continue(T128* C){ +T2 _next_event=0; +T0* _s=(void*)0; +T8 _c_widget=(void*)0; +/*l109c5/event_catcher.e*/ +_next_event=basic_vision_next_event; +/*l110c5/event_catcher.e*/ +/*SFN*/(C->_current_event_type/*i11p*/)=_next_event; +/*l111c5/event_catcher.e*/ +/*SFN*/(C->_suspend/*i11p*/)=((T6)(0)); +while (!((T6)(((_next_event)==(INT8_C(-1)))||((T6)((/*RF2*/(C)->_suspend/*i11p*/)))))) +{ +/*l118c5/event_catcher.e*/ +_c_widget=basic_vision_event_widget; +/*l119c5/event_catcher.e*/ +_s=r227reference_at((T227*)((/*RF2*/(C)->_widget/*i11p*/)),_c_widget); +/*l120c5/event_catcher.e*/ +if((_s)!=((void*)((void*)0))){ +r128emit_event(C,_s,_next_event); +} +else if((T6)(((T6)((((int32_t)(_next_event))>(INT32_C(3)))&&((T6)((r2in_range(_next_event,INT32_C(40),INT32_C(59)))==(0)))))&&((T6)((_next_event)!=(INT8_C(100)))))){ +/*l126c6/event_catcher.e*/ +_s=r128search_widget(C,_c_widget); +/*l127c6/event_catcher.e*/ +if((_s)!=((void*)((void*)0))){ +r128emit_event((T128*)((/*RF2*/(C)->_event_catcher_found/*i11p*/)),_s,_next_event); +} +else{ +} +} +/*l137c5/event_catcher.e*/ +_next_event=basic_vision_next_event; +/*l138c5/event_catcher.e*/ +/*SFN*/(C->_current_event_type/*i11p*/)=_next_event; +} +}/*--*/ +T0*oBC26vision=(void*)0; +int fBC26vision=0; + +/*EVENT_CATCHER*/T0* r128vision(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC26vision==0){fBC26vision=1;{ +tmp0=((T0*)(new64())); +r64graphic_init(((T64*)tmp0)); +oBC26vision=tmp0; +}} +return oBC26vision; +}/*--*/ +T0*oBC13io=(void*)0; + +/*EVENT_CATCHER*/void r128make(T128* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _ev=(void*)0; +T2 _i=0; +/*l72c4/event_catcher.e*/ +/*SFN*/(C->_graphic_connection/*i11p*/)=a1; +/*l73c4/event_catcher.e*/ +tmp0=((T0*)(new227())); +r227make(((T227*)tmp0)); +/*SFN*/(C->_widget/*i11p*/)=tmp0; +/*l74c4/event_catcher.e*/ +tmp0=((T0*)(new232())); +r232make(((T232*)tmp0),INT32_C(65)); +/*SFN*/(C->_event/*i11p*/)=tmp0; +/*l75c4/event_catcher.e*/ +_i=(/*RF2*/((T232*)((/*RF2*/(C)->_event/*i11p*/)))->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l80c5/event_catcher.e*/ +tmp0=((T0*)(new234())); +r234make(((T234*)tmp0)); +_ev=tmp0; +/*l122c12/fast_array.e*/ +((/*RF2*/((T232*)((/*RF2*/(C)->_event/*i11p*/)))->_storage/*3p*/))[_i]=(_ev); +/*l82c5/event_catcher.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l84c4/event_catcher.e*/ +tmp0=((T0*)(new230())); +r230make(((T230*)tmp0)); +/*SFN*/(C->_pointer_move_event/*i11p*/)=tmp0; +/*l85c4/event_catcher.e*/ +tmp0=((T0*)(new228())); +r228make(((T228*)tmp0)); +/*SFN*/(C->_geometry_change_event/*i11p*/)=tmp0; +/*l86c4/event_catcher.e*/ +tmp0=((T0*)(new226())); +r226make(((T226*)tmp0)); +/*SFN*/(C->_extension_devices/*i11p*/)=tmp0; +}/*--*/ + +/*ROOT_WINDOW*/void r72default_create(T72* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l22c4/root_window.e*/ +r72container_init(C); +/*l23c4/root_window.e*/ +/*SFN*/(C->_width/*11p*/)=(/*RF2*/((T64*)(r72vision()))->_display_width/*6p*/); +/*l24c4/root_window.e*/ +/*SFN*/(C->_height/*11p*/)=(/*RF2*/((T64*)(r72vision()))->_display_height/*6p*/); +/*l25c4/root_window.e*/ +/*SFN*/(C->_min_width/*11p*/)=(/*RF2*/(C)->_width/*11p*/); +/*l26c4/root_window.e*/ +/*SFN*/(C->_min_height/*11p*/)=(/*RF2*/(C)->_height/*11p*/); +/*l27c4/root_window.e*/ +/*SFN*/(C->_std_width/*11p*/)=(/*RF2*/(C)->_width/*11p*/); +/*l28c4/root_window.e*/ +/*SFN*/(C->_std_height/*11p*/)=(/*RF2*/(C)->_height/*11p*/); +/*l29c4/root_window.e*/ +tmp0=((T0*)(new158())); +/*SFN*/(C->_layout/*11p*/)=tmp0; +/*l30c11/root_window.e*/ +r158set_container((T158*)((/*RF2*/(C)->_layout/*11p*/)),(T0*)C); +/*l31c4/root_window.e*/ +/*SFN*/(C->_widget/*11p*/)=basic_window_root_id; +/*l32c11/root_window.e*/ +r64register((T64*)(r72vision()),(T0*)C); +}/*--*/ + +/*ROOT_WINDOW*/T0* r72vision(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC26vision==0){fBC26vision=1;{ +tmp0=((T0*)(new64())); +r64graphic_init(((T64*)tmp0)); +oBC26vision=tmp0; +}} +return oBC26vision; +}/*--*/ + +/*ROOT_WINDOW*/T2 r72hash_code(T72* C){ +T2 R=0; +R=r8hash_code((/*RF2*/(C)->_widget/*11p*/)); +return R; +}/*--*/ + +/*ROOT_WINDOW*/void r72container_init(T72* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +tmp0=((T0*)(new225())); +r225make(((T225*)tmp0),INT32_C(0)); +/*SFN*/(C->_child/*11p*/)=tmp0; +}/*--*/ + +/*STD_OUTPUT*/void r53filtered_flush(T53* C){ +/*l59c4/std_output.e*/ +if(((int32_t)((/*RF2*/(C)->_buffer_position/*4p*/)))>(INT32_C(0))){ +r53write_buffer(C); +} +/*l62c4/std_output.e*/ +io_flush((stdout)); +}/*--*/ + +/*STD_OUTPUT*/void r53filtered_put_character(T53* C,T3 a1){ +/*l47c4/std_output.e*/ +if(((int32_t)((/*RF2*/(C)->_buffer_position/*4p*/)))>=(INT32_C(4096))){ +r53write_buffer(C); +} +/*l50c11/std_output.e*/ +((/*RF2*/(C)->_buffer/*4p*/))[(/*RF2*/(C)->_buffer_position/*4p*/)]=(a1); +/*l51c4/std_output.e*/ +/*SFN*/(C->_buffer_position/*4p*/)=((int32_t)((/*RF2*/(C)->_buffer_position/*4p*/)))+(INT32_C(1)); +/*l52c4/std_output.e*/ +if((a1)==(((T3)'\n'))){ +r53write_buffer(C); +} +}/*--*/ +T0*oBC13std_output=(void*)0; +int fBC13std_output=0; + +/*STD_OUTPUT*/T0* r53std_output(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC13std_output==0){fBC13std_output=1;{ +tmp0=((T0*)(new53())); +r53make(((T53*)tmp0)); +oBC13std_output=tmp0; +}} +return oBC13std_output; +}/*--*/ + +/*STD_OUTPUT*/void r53se_atexit(void){ +r53filtered_flush((T53*)(r53std_output())); +}/*--*/ + +/*STD_OUTPUT*/void r53make(T53* C){ +/*l40c4/std_output.e*/ +/*SFN*/(C->_buffer/*4p*/)=new9(INT32_C(4096)); +/*l41c4/std_output.e*/ +/*SFN*/(C->_capacity/*4p*/)=INT32_C(4096); +}/*--*/ + +/*STD_OUTPUT*/void r53write_buffer(T53* C){ +if(((int32_t)((/*RF2*/(C)->_buffer_position/*4p*/)))>(INT32_C(0))){ +/*l126c5/std_output.e*/ +io_fwrite((/*RF2*/(C)->_buffer/*4p*/),(/*RF2*/(C)->_buffer_position/*4p*/),(stdout)); +/*l127c5/std_output.e*/ +/*SFN*/(C->_buffer_position/*4p*/)=INT32_C(0); +} +}/*--*/ + +/*STD_OUTPUT*/void r53flush(T53* C){ +r53filtered_flush(C); +}/*--*/ + +/*STD_OUTPUT*/void r53put_string(T53* C,T0* a1){ +T2 _i=0; +T2 _count=0; +/*l47c5/output_stream_tools.e*/ +_i=INT32_C(1); +/*l48c5/output_stream_tools.e*/ +_count=(/*RF2*/(((T7*)a1))->_count/*3p*/); +while (!(((int32_t)(_i))>(_count))) +{ +/*l21c4/output_stream.e*/ +r53filtered_put_character(C,((/*RF2*/(((T7*)a1))->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]); +/*l53c5/output_stream_tools.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*STD_OUTPUT*/void r53put_line(T53* C,T0* a1){ +/*l70c4/std_output.e*/ +r53write_buffer(C); +/*l71c6/std_output.e*/ +r7add_last(((T7*)a1),((T3)'\n')); +/*l72c4/std_output.e*/ +io_fwrite((/*RF2*/(((T7*)a1))->_storage/*3p*/),(/*RF2*/(((T7*)a1))->_count/*3p*/),(stdout)); +/*l73c6/std_output.e*/ +r7remove_last(((T7*)a1)); +}/*--*/ + +/*STD_OUTPUT*/void r53dispose(T53* C){ +(/*RF2*/(C)->_filter/*4p*/)=(void*)0; +}/*--*/ +T0*oBC13std_input=(void*)0; +int fBC13std_input=0; + +/*STD_INPUT_OUTPUT*/T0* r46std_input(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC13std_input==0){fBC13std_input=1;{ +tmp0=((T0*)(new54())); +r54make(((T54*)tmp0)); +oBC13std_input=tmp0; +}} +return oBC13std_input; +}/*--*/ + +/*STD_INPUT_OUTPUT*/T0* r46std_output(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC13std_output==0){fBC13std_output=1;{ +tmp0=((T0*)(new53())); +r53make(((T53*)tmp0)); +oBC13std_output=tmp0; +}} +return oBC13std_output; +}/*--*/ + +/*STD_INPUT_OUTPUT*/void r46disconnect(void){ +/*l37c4/std_input.e*/ +(/*RF2*/((T54*)(r46std_input()))->_filter/*3p*/)=(void*)0; +/*l34c4/std_output.e*/ +(/*RF2*/((T53*)(r46std_output()))->_filter/*4p*/)=(void*)0; +}/*--*/ + +/*STD_INPUT_OUTPUT*/T6 r46is_connected(void){ +T6 R=0; +R=((T6)((T6)(((T6)(((r46std_input())!=((void*)((void*)0)))&&((T6)(((/*UT*/(void)((T54*)(r46std_input()))),/*RF1is_connected*/1)))))&&((T6)((T6)(((r46std_output())!=((void*)((void*)0)))&&((T6)(((/*UT*/(void)((T53*)(r46std_output()))),/*RF1is_connected*/1))))))))); +return R; +}/*--*/ + +/*STD_INPUT_OUTPUT*/void r46put_string(T0* a1){ +T2 _i=0; +T2 _count=0; +/*l47c5/output_stream_tools.e*/ +_i=INT32_C(1); +/*l48c5/output_stream_tools.e*/ +_count=(/*RF2*/(((T7*)a1))->_count/*3p*/); +while (!(((int32_t)(_i))>(_count))) +{ +/*l21c4/output_stream.e*/ +r53filtered_put_character((T53*)(r46std_output()),((/*RF2*/(((T7*)a1))->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))]); +/*l53c5/output_stream_tools.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*STD_INPUT_OUTPUT*/void r46dispose(void){ +if(r46is_connected()){ +r46disconnect(); +} +}/*--*/ + +/*X_INPUT_EXTENSION*/void r175make(T175* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _size=0; +T2 _i=0; +T8 _device_list=(void*)0; +T0* _device=(void*)0; +/*l13c4/x_input_extension.e*/ +_device_list=x_list_input_devices(/*$*/&_size); +/*l14c4/x_input_extension.e*/ +/*l15c5/x_input_extension.e*/ +tmp0=((T0*)(new205())); +r205make(((T205*)tmp0),_size); +/*SFN*/(C->_devices/*p*/)=tmp0; +/*l16c5/x_input_extension.e*/ +_i=INT32_C(0); +while (!(((int32_t)(_i))>=(_size))) +{ +/*l20c5/x_input_extension.e*/ +tmp0=((T0*)(new67())); +r67make(((T67*)tmp0),_device_list,_i); +_device=tmp0; +/*l122c12/fast_array.e*/ +((/*RF2*/((T205*)((/*RF2*/(C)->_devices/*p*/)))->_storage/*3p*/))[_i]=(_device); +/*l22c5/x_input_extension.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l24c4/x_input_extension.e*/ +XFreeDeviceList(_device_list); +}/*--*/ + +/*X11*/void r143default_create(void){ +T0* _v=(void*)0; +_v=r143vision(); +}/*--*/ +T0*oBC143x_input_extension=(void*)0; +int fBC143x_input_extension=0; + +/*X11*/T0* r143x_input_extension(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC143x_input_extension==0){fBC143x_input_extension=1;{ +tmp0=((T0*)(new175())); +r175make(((T175*)tmp0)); +oBC143x_input_extension=tmp0; +}} +return oBC143x_input_extension; +}/*--*/ + +/*X11*/T6 r143has_x_input_extension(void){ +T6 R=0; +R=((T6)(x_query_extension(r7to_external(((T7*)ms143_1472358418))))); +return R; +}/*--*/ + +/*X11*/T0* r143get_atom_name(T2 a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +T8 _name=(void*)0; +if((a1)!=(INT8_C(0))){ +/*l34c5/x11.e*/ +_name=x_get_atom_name(a1); +/*l35c5/x11.e*/ +tmp0=((T0*)(new7())); +r7from_external_copy(((T7*)tmp0),_name); +R=tmp0; +/*l36c5/x11.e*/ +XFree(_name); +} +return R; +}/*--*/ + +/*X11*/T0* r143vision(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC26vision==0){fBC26vision=1;{ +tmp0=((T0*)(new64())); +r64graphic_init(((T64*)tmp0)); +oBC26vision=tmp0; +}} +return oBC26vision; +}/*--*/ + +/*X_INPUT_DEVICE*/void r67handle_event(T67* C,T2 a1,T0* a2){ +T2 _event_index=0; +T0* _action_list=(void*)0; +T0* _signal=(void*)0; +/*l58c4/x_input_device.e*/ +_event_index=r215at((T215*)((/*RF2*/(C)->_events_indexes/*14p*/)),a1); +/*l59c4/x_input_device.e*/ +_action_list=r218reference_at((T218*)((/*RF2*/(C)->_actions/*14p*/)),a2); +/*l60c4/x_input_device.e*/ +if((_action_list)!=((void*)((void*)0))){ +/*l61c5/x_input_device.e*/ +_signal=((/*RF2*/(((T217*)_action_list))->_storage/*3p*/))[_event_index]; +/*l62c5/x_input_device.e*/ +if((_signal)!=((void*)((void*)0))){ +r216emit(((T216*)_signal),(T0*)C); +} +} +}/*--*/ + +/*X_INPUT_DEVICE*/T0* r67vision(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC26vision==0){fBC26vision=1;{ +tmp0=((T0*)(new64())); +r64graphic_init(((T64*)tmp0)); +oBC26vision=tmp0; +}} +return oBC26vision; +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_proximity_out(T67* C,T0* a1,T0* a2){ +r67when_event(C,INT32_C(6),a1,a2); +}/*--*/ + +/*X_INPUT_DEVICE*/void r67connect(T67* C){ +T2 _i=0; +/*l526c18/vision.e*/ +r128add_extension((T128*)((/*RF2*/((T64*)(r67vision()))->_event_catcher/*6p*/)),(T0*)C); +/*l93c4/x_input_device.e*/ +/*SFN*/(C->_x_device/*14p*/)=x_open_device((/*RF2*/(C)->_device_id/*14p*/)); +/*l94c4/x_input_device.e*/ +/*SFN*/(C->_events_classes/*14p*/)=x_device_init_events((/*RF2*/(C)->_x_device/*14p*/),((void*)((/*RF2*/((T214*)((/*RF2*/(C)->_events_id/*14p*/)))->_storage/*3p*/)))); +/*l95c4/x_input_device.e*/ +_i=(/*RF2*/((T214*)((/*RF2*/(C)->_events_id/*14p*/)))->_upper/*3p*/); +while (!(((int32_t)(_i))<(INT32_C(0)))) +{ +/*l103c20/x_input_device.e*/ +r215put((T215*)((/*RF2*/(C)->_events_indexes/*14p*/)),_i,((/*RF2*/((T214*)((/*RF2*/(C)->_events_id/*14p*/)))->_storage/*3p*/))[_i]); +/*l104c5/x_input_device.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_button_released(T67* C,T0* a1,T0* a2){ +r67when_event(C,INT32_C(3),a1,a2); +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_event(T67* C,T2 a1,T0* a2,T0* a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* _action_list=(void*)0; +T0* _signal=(void*)0; +/*l251c4/x_input_device.e*/ +_action_list=r218reference_at((T218*)((/*RF2*/(C)->_actions/*14p*/)),a2); +/*l252c4/x_input_device.e*/ +if((_action_list)==((void*)((void*)0))){ +/*l253c5/x_input_device.e*/ +tmp0=((T0*)(new217())); +r217make(((T217*)tmp0),r214count((T214*)((/*RF2*/(C)->_events_id/*14p*/)))); +_action_list=tmp0; +/*l254c13/x_input_device.e*/ +r218add((T218*)((/*RF2*/(C)->_actions/*14p*/)),_action_list,a2); +/*l255c5/x_input_device.e*/ +x_device_select_events((/*RF2*/(((T72*)a2))->_widget/*11p*/),(/*RF2*/(C)->_events_classes/*14p*/)); +} +/*l257c4/x_input_device.e*/ +_signal=((/*RF2*/(((T217*)_action_list))->_storage/*3p*/))[a1]; +/*l258c4/x_input_device.e*/ +if((_signal)==((void*)((void*)0))){ +/*l259c5/x_input_device.e*/ +tmp0=((T0*)(new216())); +r216make(((T216*)tmp0)); +_signal=tmp0; +/*l122c12/fast_array.e*/ +((/*RF2*/(((T217*)_action_list))->_storage/*3p*/))[a1]=(_signal); +} +/*l32c14/signal_1.e*/ +r254add_last((T254*)((/*RF2*/(((T216*)_signal))->_callbacks/*3p*/)),a3); +}/*--*/ + +/*X_INPUT_DEVICE*/void r67make(T67* C,T8 a1,T2 a2){ +/*[INTERNAL_C_LOCAL list*/ +int tmp0; +T0* tmp1; +/*INTERNAL_C_LOCAL list]*/ +int _x11=0; +T8 _current_class_info=(void*)0; +T2 _i=0; +T0* _key=(void*)0; +T0* _button=(void*)0; +T0* _axes=(void*)0; +tmp0=M143; +r143default_create(); +_x11=tmp0; +/*l15c4/x_input_device.e*/ +tmp1=((T0*)(new7())); +r7from_external_copy(((T7*)tmp1),x_device_info_name(a1,a2)); +/*SFN*/(C->_name/*14p*/)=tmp1; +/*l16c4/x_input_device.e*/ +/*SFN*/(C->_device_id/*14p*/)=x_device_info_id(a1,a2); +/*l17c4/x_input_device.e*/ +/*SFN*/(C->_type/*14p*/)=r143get_atom_name(x_device_info_type(a1,a2)); +/*l18c4/x_input_device.e*/ +/*SFN*/(C->_is_current_pointer/*14p*/)=((T6)(x_device_info_is_pointer(a1,a2))); +/*l19c4/x_input_device.e*/ +/*SFN*/(C->_is_current_keyboard/*14p*/)=((T6)(x_device_info_is_keyboard(a1,a2))); +/*l20c4/x_input_device.e*/ +/*SFN*/(C->_is_available_extension/*14p*/)=((T6)(x_device_info_is_available_extension(a1,a2))); +/*l21c4/x_input_device.e*/ +/*l22c5/x_input_device.e*/ +tmp1=((T0*)(new223())); +r223make(((T223*)tmp1),INT32_C(0)); +/*SFN*/(C->_key_capabilities/*14p*/)=tmp1; +/*l23c5/x_input_device.e*/ +tmp1=((T0*)(new222())); +r222make(((T222*)tmp1),INT32_C(0)); +/*SFN*/(C->_button_capabilities/*14p*/)=tmp1; +/*l24c5/x_input_device.e*/ +tmp1=((T0*)(new221())); +r221make(((T221*)tmp1),INT32_C(0)); +/*SFN*/(C->_axes_capabilities/*14p*/)=tmp1; +/*l25c5/x_input_device.e*/ +_i=x_device_info_num_classes(a1,a2); +/*l26c5/x_input_device.e*/ +_current_class_info=x_device_info_class_info(a1,a2); +while (!((_i)==(INT8_C(0)))) +{ +/*l30c5/x_input_device.e*/ +if(x_is_key_class_info(_current_class_info)){ +/*l31c6/x_input_device.e*/ +tmp1=((T0*)(new139())); +r139make(((T139*)tmp1),_current_class_info); +_key=tmp1; +/*l32c23/x_input_device.e*/ +r223add_last((T223*)((/*RF2*/(C)->_key_capabilities/*14p*/)),_key); +} +else if(x_is_button_class_info(_current_class_info)){ +/*l34c6/x_input_device.e*/ +tmp1=((T0*)(new142())); +r142make(((T142*)tmp1),_current_class_info); +_button=tmp1; +/*l35c26/x_input_device.e*/ +r222add_last((T222*)((/*RF2*/(C)->_button_capabilities/*14p*/)),_button); +} +else{ +/*l40c6/x_input_device.e*/ +tmp1=((T0*)(new141())); +r141make(((T141*)tmp1),_current_class_info); +_axes=tmp1; +/*l41c24/x_input_device.e*/ +r221add_last((T221*)((/*RF2*/(C)->_axes_capabilities/*14p*/)),_axes); +} +/*l43c5/x_input_device.e*/ +_current_class_info=x_next_class_info(_current_class_info); +/*l44c5/x_input_device.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +} +/*l46c4/x_input_device.e*/ +tmp1=((T0*)(new218())); +r218make(((T218*)tmp1)); +/*SFN*/(C->_actions/*14p*/)=tmp1; +/*l47c4/x_input_device.e*/ +tmp1=((T0*)(new215())); +r215make(((T215*)tmp1)); +/*SFN*/(C->_events_indexes/*14p*/)=tmp1; +/*l48c4/x_input_device.e*/ +tmp1=((T0*)(new214())); +r214make(((T214*)tmp1),INT32_C(7)); +/*SFN*/(C->_events_id/*14p*/)=tmp1; +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_moved(T67* C,T0* a1,T0* a2){ +r67when_event(C,INT32_C(4),a1,a2); +}/*--*/ + +/*X_INPUT_DEVICE*/T2 r67proximity_axis_data(T2 a1){ +T2 R=0; +R=x_device_proximity_event_data(((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_button_pressed(T67* C,T0* a1,T0* a2){ +r67when_event(C,INT32_C(2),a1,a2); +}/*--*/ + +/*X_INPUT_DEVICE*/T2 r67motion_axis_data(T2 a1){ +T2 R=0; +R=x_device_motion_event_data(((int32_t)(a1))-(INT32_C(1))); +return R; +}/*--*/ + +/*X_INPUT_DEVICE*/void r67when_proximity_in(T67* C,T0* a1,T0* a2){ +r67when_event(C,INT32_C(5),a1,a2); +}/*--*/ + +/*STD_ERROR*/void r43put_string(T0* a1){ +T2 _i=0; +T2 _count=0; +/*l47c5/output_stream_tools.e*/ +_i=INT32_C(1); +/*l48c5/output_stream_tools.e*/ +_count=(/*RF2*/(((T7*)a1))->_count/*3p*/); +while (!(((int32_t)(_i))>(_count))) +{ +/*l37c4/std_error.e*/ +io_putc(((/*RF2*/(((T7*)a1))->_storage/*3p*/))[((int32_t)(_i))-(INT32_C(1))],(stderr)); +/*l53c5/output_stream_tools.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*STD_ERROR*/void r43put_line(T0* a1){ +/*l72c4/output_stream_tools.e*/ +r43put_string(a1); +/*l37c4/std_error.e*/ +io_putc(((T3)'\n'),(stderr)); +}/*--*/ + +/*STD_ERROR*/void r43dispose(T43* C){ +(/*RF2*/(C)->_filter/*p*/)=(void*)0; +}/*--*/ + +/*WACOM_POINTER*/T0* r69type_to_name(T2 a1){ +T0* R=(void*)0; +/*[INSPECT*/ +{int inspect_tmp_1=a1; +switch(inspect_tmp_1){ +case 2066: +R=ms69_10739024; +break; +case 2049: +R=ms69_10739017; +break; +case 2082: +R=ms69_10739030; +break; +case 2083: +R=ms69_1940108584; +break; +case 2067: +R=ms69_1619665677; +break; +case 2181: +R=ms69_1961093439; +break; +case 2098: +R=ms69_1874520032; +break; +case 3346: +R=ms69_104371267; +break; +case 2323: +R=ms69_104371129; +break; +case 2090: +R=ms69_1257860908; +break; +case 2091: +R=ms69_2057747851; +break; +case 2075: +R=ms69_1699147265; +break; +case 2331: +R=ms69_1501987274; +break; +default:; +/*l93c5/wacom_pointer.e*/ +R=ms25_0bc69c15l93; +/*l1121c4/string.e*/ +(/*RF2*/(((T7*)R))->_count/*3p*/)=INT32_C(0); +/*l95c13/wacom_pointer.e*/ +r2append_in(a1,R); +} +}/*INSPECT]*/ +return R; +}/*--*/ + +/*WACOM_POINTER*/T5 r69mean(T0* a1){ +T5 R=0; +T11 _sum=0; +T2 _i=0; +/*l153c4/wacom_pointer.e*/ +_i=(/*RF2*/(((T213*)a1))->_lower/*5p*/); +while (!(((int32_t)(_i))>((/*RF2*/(((T213*)a1))->_upper/*5p*/)))) +{ +/*l158c5/wacom_pointer.e*/ +_sum=((int64_t)(_sum))+(/*IC*/(T11)(r213item(((T213*)a1),_i))); +/*l159c5/wacom_pointer.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l161c4/wacom_pointer.e*/ +R=((T5)(_sum))/(/*IC*/(T11)(r213count(((T213*)a1)))); +return R; +}/*--*/ + +/*WACOM_POINTER*/void r69update_predicted_position(T69* C,T5 a1,T5 a2,T5 a3){ +T5 _dt=0; +T5 _s3x=0; +T5 _s3y=0; +T5 _s3=0; +T5 _s3xn=0; +T5 _s3yn=0; +T5 _a3x=0; +T5 _a3y=0; +T5 _a3xm=0; +T5 _a3ym=0; +T5 _a4x=0; +T5 _a4y=0; +/*l363c4/wacom_pointer.e*/ +_dt=(a3)-((/*RF2*/(C)->_t2/*25p*/)); +/*l364c4/wacom_pointer.e*/ +_s3x=((a1)-((/*RF2*/(C)->_x2/*25p*/)))/(_dt); +/*l365c4/wacom_pointer.e*/ +_s3y=((a2)-((/*RF2*/(C)->_y2/*25p*/)))/(_dt); +/*l366c4/wacom_pointer.e*/ +_s3=sqrt(((_s3x)*(_s3x))+((_s3y)*(_s3y))); +/*l367c4/wacom_pointer.e*/ +if(((T5)((_s3)))!=(((T5)(INT8_C(0))))){ +/*l368c5/wacom_pointer.e*/ +_s3xn=(_s3x)/(_s3); +/*l369c5/wacom_pointer.e*/ +_s3yn=(_s3y)/(_s3); +} +/*l372c4/wacom_pointer.e*/ +_dt=((a3)-((/*RF2*/(C)->_t1/*25p*/)))/(/*IC*/(T5)(INT8_C(2))); +/*l373c4/wacom_pointer.e*/ +_a3x=((_s3x)-((/*RF2*/(C)->_s2x/*25p*/)))/(_dt); +/*l374c4/wacom_pointer.e*/ +_a3y=((_s3y)-((/*RF2*/(C)->_s2y/*25p*/)))/(_dt); +/*l375c4/wacom_pointer.e*/ +_a3xm=((_a3x)*((/*RF2*/(C)->_s2xn/*25p*/)))+((_a3y)*((/*RF2*/(C)->_s2yn/*25p*/))); +/*l376c4/wacom_pointer.e*/ +_a3ym=((-(_a3x))*((/*RF2*/(C)->_s2yn/*25p*/)))+((_a3y)*((/*RF2*/(C)->_s2xn/*25p*/))); +/*l377c4/wacom_pointer.e*/ +_a4x=((_s3xn)*(_a3xm))-((_s3yn)*(_a3ym)); +/*l378c4/wacom_pointer.e*/ +_a4y=((_s3yn)*(_a3xm))+((_s3xn)*(_a3ym)); +/*l396c4/wacom_pointer.e*/ +_dt=((((/*RF2*/(C)->_prediction_time/*25p*/))+((/*RF2*/(C)->_t2/*25p*/)))-((/*RF2*/(C)->_t1/*25p*/)))/((((a3)+((/*RF2*/(C)->_t1/*25p*/)))-((/*RF2*/(C)->_t2/*25p*/)))-((/*RF2*/(C)->_t0/*25p*/))); +/*l397c4/wacom_pointer.e*/ +_a4x=(((_a4x)+(_a3x))+(((_a3x)-((/*RF2*/(C)->_a2x/*25p*/)))*(_dt)))/(/*IC*/(T5)(INT8_C(2))); +/*l398c4/wacom_pointer.e*/ +_a4y=(((_a4y)+(_a3y))+(((_a3y)-((/*RF2*/(C)->_a2y/*25p*/)))*(_dt)))/(/*IC*/(T5)(INT8_C(2))); +/*l400c4/wacom_pointer.e*/ +_dt=(((a3)-((/*RF2*/(C)->_t2/*25p*/)))+((/*RF2*/(C)->_prediction_time/*25p*/)))/(/*IC*/(T5)(INT8_C(2))); +/*l401c4/wacom_pointer.e*/ +/*SFN*/(C->_predicted_x/*25p*/)=((int32_t)((a1)+(((/*RF2*/(C)->_prediction_time/*25p*/))*((_s3x)+((_a4x)*(_dt)))))); +/*l402c4/wacom_pointer.e*/ +/*SFN*/(C->_predicted_y/*25p*/)=((int32_t)((a2)+(((/*RF2*/(C)->_prediction_time/*25p*/))*((_s3y)+((_a4y)*(_dt)))))); +/*l405c4/wacom_pointer.e*/ +/*SFN*/(C->_x2/*25p*/)=a1; +/*l405c14/wacom_pointer.e*/ +/*SFN*/(C->_y2/*25p*/)=a2; +/*l406c4/wacom_pointer.e*/ +/*SFN*/(C->_s2x/*25p*/)=_s3x; +/*l406c16/wacom_pointer.e*/ +/*SFN*/(C->_s2y/*25p*/)=_s3y; +/*l407c4/wacom_pointer.e*/ +/*SFN*/(C->_s2xn/*25p*/)=_s3xn; +/*l407c18/wacom_pointer.e*/ +/*SFN*/(C->_s2yn/*25p*/)=_s3yn; +/*l408c4/wacom_pointer.e*/ +/*SFN*/(C->_a2x/*25p*/)=_a3x; +/*l408c16/wacom_pointer.e*/ +/*SFN*/(C->_a2y/*25p*/)=_a3y; +/*l409c4/wacom_pointer.e*/ +/*SFN*/(C->_t0/*25p*/)=(/*RF2*/(C)->_t1/*25p*/); +/*l409c14/wacom_pointer.e*/ +/*SFN*/(C->_t1/*25p*/)=(/*RF2*/(C)->_t2/*25p*/); +/*l409c24/wacom_pointer.e*/ +/*SFN*/(C->_t2/*25p*/)=a3; +}/*--*/ + +/*WACOM_POINTER*/T0* r69twin(T69* C){ +T0* R=(void*)0; +R=((void*)new69()); +*((T69*)R)=*C; +return R; +}/*--*/ + +/*WACOM_POINTER*/void r69make(T69* C,T0* a1){ +/*l11c4/wacom_pointer.e*/ +/*SFN*/(C->_xinput_ivy/*25p*/)=a1; +/*l12c4/wacom_pointer.e*/ +/*SFN*/(C->_prediction_time/*25p*/)=/*IC*/(T5)(INT8_C(25)); +}/*--*/ + +/*WACOM_POINTER*/void r69print_data_in(T69* C,T0* a1,T2 a2,T2 a3,T2 a4,T2 a5,T2 a6,T2 a7,T2 a8,T0* a9){ +/*l202c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_1461); +/*l203c27/wacom_pointer.e*/ +r2append_in(r69device_to_screen_x(C,a2),a1); +/*l204c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_1466); +/*l205c27/wacom_pointer.e*/ +r2append_in(r69device_to_screen_y(C,a3),a1); +/*l206c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_23436791); +/*l207c13/wacom_pointer.e*/ +r2append_in(a4,a1); +/*l208c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_4725661); +/*l209c15/wacom_pointer.e*/ +r10append_in(((int16_t)(a5)),a1); +/*l210c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_4725666); +/*l211c15/wacom_pointer.e*/ +r10append_in(((int16_t)(a6)),a1); +/*l212c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_952626); +/*l213c15/wacom_pointer.e*/ +r10append_in(((int16_t)(a7)),a1); +/*l214c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_1756148648); +/*l215c37/wacom_pointer.e*/ +r2append_in(r69device_to_screen_x(C,(/*RF2*/(C)->_predicted_x/*25p*/)),a1); +/*l216c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_1756148653); +/*l217c37/wacom_pointer.e*/ +r2append_in(r69device_to_screen_y(C,(/*RF2*/(C)->_predicted_y/*25p*/)),a1); +/*l218c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_190991); +/*l219c13/wacom_pointer.e*/ +r7append(((T7*)a1),r69type_to_name(/*IC*/(T2)(r2high_16(a5)))); +/*l220c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_2112369621); +/*l221c58/wacom_pointer.e*/ +r2append_in((((r10to_integer_32(r2high_16(a6)))<<(INT8_C(16)))|/*IC*/(T2)(r2high_16(a7))),a1); +/*l222c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_188916); +/*l223c10/wacom_pointer.e*/ +r2append_in(a8,a1); +/*l224c14/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_22702411); +/*l176c4/real_general.e*/ +r5append_in_format(((T5)(a2))/(INT32_C(86400)),a1,INT32_C(6)); +/*l226c14/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_22702416); +/*l176c4/real_general.e*/ +r5append_in_format(((T5)(a3))/(INT32_C(65000)),a1,INT32_C(6)); +/*l228c13/wacom_pointer.e*/ +r7append(((T7*)a1),ms69_586741066); +/*l229c13/wacom_pointer.e*/ +r7append(((T7*)a1),a9); +}/*--*/ + +/*WACOM_POINTER*/void r69set_message_header(T69* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _history_size=0; +/*l124c4/wacom_pointer.e*/ +/*SFN*/(C->_pointer_message_header/*25p*/)=se_ms(7,s69_2179769); +/*l125c27/wacom_pointer.e*/ +r7append((T7*)((/*RF2*/(C)->_pointer_message_header/*25p*/)),a1); +/*l126c4/wacom_pointer.e*/ +/*SFN*/(C->_button_message_header/*25p*/)=se_ms(6,s69_397440); +/*l127c26/wacom_pointer.e*/ +r7append((T7*)((/*RF2*/(C)->_button_message_header/*25p*/)),a1); +/*l128c4/wacom_pointer.e*/ +_history_size=INT32_C(1); +/*l129c4/wacom_pointer.e*/ +tmp0=((T0*)(new213())); +r213make(((T213*)tmp0),INT32_C(0),_history_size); +/*SFN*/(C->_x_history/*25p*/)=tmp0; +/*l130c4/wacom_pointer.e*/ +tmp0=((T0*)(new213())); +r213make(((T213*)tmp0),INT32_C(0),_history_size); +/*SFN*/(C->_y_history/*25p*/)=tmp0; +/*l131c4/wacom_pointer.e*/ +tmp0=((T0*)(new213())); +r213make(((T213*)tmp0),INT32_C(0),_history_size); +/*SFN*/(C->_time_history/*25p*/)=tmp0; +}/*--*/ + +/*WACOM_POINTER*/void r69button(T69* C,T6 a1,T0* a2){ +T2 _x=0; +T2 _y=0; +T2 _presure=0; +T5 _t3=0; +T0* _message=(void*)0; +/*l238c4/wacom_pointer.e*/ +_x=r67motion_axis_data(INT32_C(1)); +/*l239c4/wacom_pointer.e*/ +_y=r67motion_axis_data(INT32_C(2)); +/*l241c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_x_history/*25p*/))); +/*l242c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_x_history/*25p*/)),_x); +/*l243c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_y_history/*25p*/))); +/*l244c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_y_history/*25p*/)),_y); +/*l245c17/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_time_history/*25p*/))); +/*l246c17/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_time_history/*25p*/)),x_device_event_time); +/*l247c4/wacom_pointer.e*/ +_t3=r69mean((/*RF2*/(C)->_time_history/*25p*/)); +/*l248c4/wacom_pointer.e*/ +if(((T5)((_t3)))!=(((T5)((/*RF2*/(C)->_t2/*25p*/))))){ +r69update_predicted_position(C,r69mean((/*RF2*/(C)->_x_history/*25p*/)),r69mean((/*RF2*/(C)->_y_history/*25p*/)),_t3); +} +/*l251c4/wacom_pointer.e*/ +_message=ms25_0bc69; +/*l252c12/wacom_pointer.e*/ +r7copy(((T7*)_message),(/*RF2*/(C)->_button_message_header/*25p*/)); +/*l253c12/wacom_pointer.e*/ +r7append(((T7*)_message),ms25_4487261bc69); +/*l254c26/wacom_pointer.e*/ +r2append_in(x_device_button_event_number,_message); +/*l255c12/wacom_pointer.e*/ +r7append(((T7*)_message),ms69_4738061); +/*l256c4/wacom_pointer.e*/ +if(a1){ +r7append(((T7*)_message),ms69_15980); +} +else{ +r7append(((T7*)_message),ms69_697); +} +/*l261c4/wacom_pointer.e*/ +_presure=r67motion_axis_data(INT32_C(3)); +/*l262c4/wacom_pointer.e*/ +r69print_data_in(C,_message,_x,_y,_presure,r67motion_axis_data(INT32_C(4)),r67motion_axis_data(INT32_C(5)),r67motion_axis_data(INT32_C(6)),x_device_event_time,ms69_56246305); +/*l266c19/wacom_pointer.e*/ +r70send_message((T70*)((/*RF2*/((T25*)((/*RF2*/(C)->_xinput_ivy/*25p*/)))->_ivy/*8p*/)),_message); +}/*--*/ + +/*WACOM_POINTER*/void r69proximity(T69* C,T6 a1,T0* a2){ +T2 _x=0; +T2 _y=0; +T5 _t3=0; +T0* _message=(void*)0; +T0* _proximity_status=(void*)0; +/*l275c4/wacom_pointer.e*/ +_x=r67proximity_axis_data(INT32_C(1)); +/*l276c4/wacom_pointer.e*/ +_y=r67proximity_axis_data(INT32_C(2)); +/*l279c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_x_history/*25p*/))); +/*l280c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_x_history/*25p*/)),_x); +/*l281c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_y_history/*25p*/))); +/*l282c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_y_history/*25p*/)),_y); +/*l283c17/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_time_history/*25p*/))); +/*l284c17/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_time_history/*25p*/)),x_device_event_time); +/*l285c4/wacom_pointer.e*/ +_t3=r69mean((/*RF2*/(C)->_time_history/*25p*/)); +/*l286c4/wacom_pointer.e*/ +if(((T5)((_t3)))!=(((T5)((/*RF2*/(C)->_t2/*25p*/))))){ +r69update_predicted_position(C,r69mean((/*RF2*/(C)->_x_history/*25p*/)),r69mean((/*RF2*/(C)->_y_history/*25p*/)),_t3); +} +/*l289c4/wacom_pointer.e*/ +if(a1){ +_proximity_status=ms69_475; +} +else{ +_proximity_status=ms69_2676; +} +/*l294c4/wacom_pointer.e*/ +_message=ms25_0bc69c15; +/*l295c12/wacom_pointer.e*/ +r7copy(((T7*)_message),(/*RF2*/(C)->_pointer_message_header/*25p*/)); +/*l296c4/wacom_pointer.e*/ +r69print_data_in(C,_message,_x,_y,r67proximity_axis_data(INT32_C(3)),r67proximity_axis_data(INT32_C(4)),r67proximity_axis_data(INT32_C(5)),r67proximity_axis_data(INT32_C(6)),x_device_event_time,_proximity_status); +/*l301c19/wacom_pointer.e*/ +r70send_message((T70*)((/*RF2*/((T25*)((/*RF2*/(C)->_xinput_ivy/*25p*/)))->_ivy/*8p*/)),_message); +}/*--*/ + +/*WACOM_POINTER*/T2 r69device_to_screen_y(T69* C,T2 a1){ +T2 R=0; +R=((int32_t)(((((T5)(a1))/(INT32_C(65000)))*(/*IC*/(T5)(INT16_C(1200))))+(/*IC*/(T5)((/*RF2*/(C)->_y_offset/*25p*/))))); +return R; +}/*--*/ + +/*WACOM_POINTER*/T2 r69device_to_screen_x(T69* C,T2 a1){ +T2 R=0; +R=((int32_t)(((((T5)(a1))/(INT32_C(86400)))*(/*IC*/(T5)(INT16_C(1600))))+(/*IC*/(T5)((/*RF2*/(C)->_x_offset/*25p*/))))); +return R; +}/*--*/ + +/*WACOM_POINTER*/void r69move(T69* C,T0* a1){ +T2 _x=0; +T2 _y=0; +T2 _presure=0; +T5 _t3=0; +T0* _message=(void*)0; +/*l170c4/wacom_pointer.e*/ +_x=r67motion_axis_data(INT32_C(1)); +/*l171c4/wacom_pointer.e*/ +_y=r67motion_axis_data(INT32_C(2)); +/*l173c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_x_history/*25p*/))); +/*l174c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_x_history/*25p*/)),_x); +/*l175c14/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_y_history/*25p*/))); +/*l176c14/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_y_history/*25p*/)),_y); +/*l177c17/wacom_pointer.e*/ +r213remove_first((T213*)((/*RF2*/(C)->_time_history/*25p*/))); +/*l178c17/wacom_pointer.e*/ +r213add_last((T213*)((/*RF2*/(C)->_time_history/*25p*/)),x_device_event_time); +/*l179c4/wacom_pointer.e*/ +_t3=r69mean((/*RF2*/(C)->_time_history/*25p*/)); +/*l180c4/wacom_pointer.e*/ +if(((T5)((_t3)))!=(((T5)((/*RF2*/(C)->_t2/*25p*/))))){ +r69update_predicted_position(C,r69mean((/*RF2*/(C)->_x_history/*25p*/)),r69mean((/*RF2*/(C)->_y_history/*25p*/)),_t3); +} +/*l183c4/wacom_pointer.e*/ +_presure=r67motion_axis_data(INT32_C(3)); +/*l184c4/wacom_pointer.e*/ +if((T6)((((int32_t)((/*RF2*/(C)->_ignored_counter/*25p*/)))<((/*RF2*/(C)->_ignore_rate/*25p*/)))&&((T6)((((/*RF2*/(C)->_old_presure/*25p*/))==(INT8_C(0)))==((_presure)==(INT8_C(0))))))){ +/*SFN*/(C->_ignored_counter/*25p*/)=((int32_t)((/*RF2*/(C)->_ignored_counter/*25p*/)))+(INT32_C(1)); +} +else{ +/*l187c5/wacom_pointer.e*/ +/*SFN*/(C->_ignored_counter/*25p*/)=INT32_C(0); +/*l188c5/wacom_pointer.e*/ +_message=ms25_0bc69c16; +/*l189c13/wacom_pointer.e*/ +r7copy(((T7*)_message),(/*RF2*/(C)->_pointer_message_header/*25p*/)); +/*l190c5/wacom_pointer.e*/ +r69print_data_in(C,_message,_x,_y,_presure,r67motion_axis_data(INT32_C(4)),r67motion_axis_data(INT32_C(5)),r67motion_axis_data(INT32_C(6)),x_device_event_time,ms69_56246305bc69); +/*l194c20/wacom_pointer.e*/ +r70send_message((T70*)((/*RF2*/((T25*)((/*RF2*/(C)->_xinput_ivy/*25p*/)))->_ivy/*8p*/)),_message); +} +/*l196c4/wacom_pointer.e*/ +/*SFN*/(C->_old_presure/*25p*/)=_presure; +}/*--*/ + +/*IVY*/void r70prepare(T70* C,T0* a1){ +T2 _i=0; +_i=INT32_C(0); +while (!(((int32_t)(_i))>((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_upper/*3p*/)))) +{ +/*l90c12/ivy.e*/ +r147expect(((T147*)a1),r146event_can_read((T146*)(((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_storage/*3p*/))[_i]))); +/*l91c12/ivy.e*/ +r147expect(((T147*)a1),r146event_exception((T146*)(((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_storage/*3p*/))[_i]))); +/*l92c5/ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +}/*--*/ + +/*IVY*/T6 r70is_ready(T70* C,T0* a1){ +T6 R=0; +T2 _i=0; +/*l100c4/ivy.e*/ +_i=INT32_C(0); +while (!((T6)((((int32_t)(_i))>((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_upper/*3p*/)))||((T6)(R))))) +{ +/*l105c5/ivy.e*/ +R=((T6)((T6)((r147event_occurred(((T147*)a1),r146event_exception((T146*)(((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_storage/*3p*/))[_i]))))||((T6)(r147event_occurred(((T147*)a1),r146event_can_read((T146*)(((/*RF2*/((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)))->_storage/*3p*/))[_i])))))))); +/*l106c5/ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l108c4/ivy.e*/ +/*SFN*/(C->_events_set/*i11p*/)=a1; +return R; +}/*--*/ + +/*IVY*/void r70continue(T70* C){ +T2 _i=0; +T0* _client=(void*)0; +/*l118c21/ivy.e*/ +r207copy((T207*)((/*RF2*/(C)->_tmp_client_list/*i11p*/)),(/*RF2*/(C)->_ivy_clients/*i11p*/)); +/*l119c5/ivy.e*/ +_i=INT32_C(0); +while (!(((int32_t)(_i))>((/*RF2*/((T207*)((/*RF2*/(C)->_tmp_client_list/*i11p*/)))->_upper/*3p*/)))) +{ +/*l123c5/ivy.e*/ +_client=((/*RF2*/((T207*)((/*RF2*/(C)->_tmp_client_list/*i11p*/)))->_storage/*3p*/))[_i]; +/*l124c5/ivy.e*/ +if(r147event_occurred((T147*)((/*RF2*/(C)->_events_set/*i11p*/)),r146event_exception(((T146*)_client)))){ +r146disconnect(((T146*)_client)); +} +else{ +/*l130c6/ivy.e*/ +if(r147event_occurred((T147*)((/*RF2*/(C)->_events_set/*i11p*/)),r146event_can_read(((T146*)_client)))){ +r146process_incomming_data(((T146*)_client)); +} +/*l133c6/ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +}/*--*/ + +/*IVY*/void r70channel_down(T70* C,T0* a1){ +/*l165c12/ivy.e*/ +r146disconnect(((T146*)a1)); +/*l166c16/ivy.e*/ +r207remove((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)),r207fast_index_of((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)),a1,INT32_C(0))); +}/*--*/ + +/*IVY*/void r70callback_runner(T0* a1,T2 a2,T212 a3){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _i=0; +T0* _match_list=(void*)0; +/*l174c4/ivy.e*/ +tmp0=((T0*)(new204())); +r204with_capacity(((T204*)tmp0),a2); +_match_list=tmp0; +while (!(((int32_t)(_i))>=(a2))) +{ +/*l179c16/ivy.e*/ +r204add_last(((T204*)_match_list),((T0*)create7from_external((a3)[_i]))); +/*l180c5/ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l182c13/ivy.e*/ +agent_launcher_FAST_ARRAY__STRING__(a1,_match_list); +}/*--*/ + +/*IVY*/T0* r70channel_up(T70* C,T2 a1,T8 a2,T8 a3,T8 a4){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T0* R=(void*)0; +/*l157c4/ivy.e*/ +tmp0=((T0*)(new146())); +r146make(((T146*)tmp0),a1,a2,a3,a4); +R=tmp0; +/*l158c16/ivy.e*/ +r207add_last((T207*)((/*RF2*/(C)->_ivy_clients/*i11p*/)),R); +return R; +}/*--*/ + +/*IVY*/void r70send_message(T70* C,T0* a1){ +/*SFN*/(C->_destination_count/*i11p*/)=send_message(r7to_external(((T7*)a1))); +}/*--*/ + +/*IVY*/void r70make(T70* C,T0* a1){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +/*l16c4/ivy.e*/ +/*SFN*/(C->_application_name_/*i11p*/)=r7twin(((T7*)a1)); +/*l17c4/ivy.e*/ +/*SFN*/(C->_ready_message_/*i11p*/)=r7twin(((T7*)a1)); +/*l18c19/ivy.e*/ +r7append((T7*)((/*RF2*/(C)->_ready_message_/*i11p*/)),se_ms(6,s70_202554)); +/*l19c4/ivy.e*/ +ivy_init(r7to_external((T7*)((/*RF2*/(C)->_application_name_/*i11p*/))),r7to_external((T7*)((/*RF2*/(C)->_ready_message_/*i11p*/))),(T0*)C,/*$*/((void*)r70channel_up),/*$*/((void*)r70channel_down),/*$*/((void*)W70callback_runner)); +/*l20c4/ivy.e*/ +tmp0=((T0*)(new211())); +r211make(((T211*)tmp0)); +/*SFN*/(C->_pattern_list/*i11p*/)=tmp0; +/*l21c4/ivy.e*/ +tmp0=((T0*)(new208())); +r208make(((T208*)tmp0)); +/*SFN*/(C->_callback_list/*i11p*/)=tmp0; +/*l22c4/ivy.e*/ +tmp0=((T0*)(new207())); +r207make(((T207*)tmp0),INT32_C(0)); +/*SFN*/(C->_ivy_clients/*i11p*/)=tmp0; +/*l23c4/ivy.e*/ +tmp0=((T0*)(new207())); +r207make(((T207*)tmp0),INT32_C(0)); +/*SFN*/(C->_tmp_client_list/*i11p*/)=tmp0; +}/*--*/ + +/*IVY*/void r70start(T70* C,T0* a1){ +/*l40c4/ivy.e*/ +IvyStart(r7to_external(((T7*)a1))); +/*l41c4/ivy.e*/ +/*SFN*/(C->_started/*i11p*/)=((T6)(1)); +}/*--*/ +T0*oBC64root_window=(void*)0; +int fBC64root_window=0; + +/*VISION*/T0* r64root_window(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC64root_window==0){fBC64root_window=1;{ +tmp0=((T0*)(new72())); +r72default_create(((T72*)tmp0)); +oBC64root_window=tmp0; +}} +return oBC64root_window; +}/*--*/ +T0*oBC13std_error=(void*)0; + +/*VISION*/void r64crash(T64* C){ +/*l274c4/any.e*/ +se_print_run_time_stack(); +/*l275c4/any.e*/ +/*l276c4/any.e*/ +se_die(INT32_C(1)); +}/*--*/ + +/*VISION*/void r64not_yet_implemented(T64* C){ +/*l305c4/any.e*/ +/*l306c14/any.e*/ +r43put_string(se_ms(611,s13_1432888418)); +/*l318c14/any.e*/ +r43put_string((T0*)(t[64])); +/*l319c14/any.e*/ +r43put_string(se_ms(3,s13_1210)); +/*l320c4/any.e*/ +r64crash(C); +}/*--*/ + +/*VISION*/void r64start(T64* C){ +/*l49c18/vision.e*/ +r128continue((T128*)((/*RF2*/(C)->_event_catcher/*6p*/))); +/*l50c15/vision.e*/ +r130run((T130*)((/*RF2*/(C)->_loop_stack/*6p*/))); +}/*--*/ + +/*VISION*/void r64register(T64* C,T0* a1){ +r227add((T227*)((/*RF2*/(C)->_widget/*6p*/)),a1,(/*RF2*/(((T72*)a1))->_widget/*11p*/)); +}/*--*/ + +/*VISION*/void r64graphic_init(T64* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _g_c=0; +T0* _ls=(void*)0; +/*l19c4/vision.e*/ +_g_c=basic_vision_init; +/*l20c4/vision.e*/ +if((_g_c)!=(INT8_C(0))){ +tmp0=((T0*)(new131())); +r131set_descriptor(((T131*)tmp0),_g_c); +/*SFN*/(C->_graphic_connection/*6p*/)=tmp0; +} +else{ +/*l23c8/vision.e*/ +r46put_string(se_ms(47,s64_1686724329)); +/*l24c5/vision.e*/ +r64not_yet_implemented(C); +} +/*l26c4/vision.e*/ +/*SFN*/(C->_display_width/*6p*/)=basic_vision_display_width; +/*l27c4/vision.e*/ +/*SFN*/(C->_display_height/*6p*/)=basic_vision_display_height; +/*l28c4/vision.e*/ +tmp0=((T0*)(new130())); +r130make(((T130*)tmp0)); +_ls=tmp0; +/*l30c4/vision_loop_stack.e*/ +(/*RF2*/(((T130*)_ls))->_vision/*4p*/)=((T0*)(C)); +/*l30c4/vision.e*/ +/*SFN*/(C->_loop_stack/*6p*/)=_ls; +/*l31c4/vision.e*/ +tmp0=((T0*)(new128())); +r128make(((T128*)tmp0),(/*RF2*/(C)->_graphic_connection/*6p*/)); +/*SFN*/(C->_event_catcher/*6p*/)=tmp0; +/*l32c4/vision.e*/ +/*SFN*/(C->_widget/*6p*/)=(/*RF2*/((T128*)((/*RF2*/(C)->_event_catcher/*6p*/)))->_widget/*i11p*/); +/*l33c15/vision.e*/ +r130add_job((T130*)((/*RF2*/(C)->_loop_stack/*6p*/)),(/*RF2*/(C)->_event_catcher/*6p*/)); +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l194c40(se_agenT25C25l194c40*u,T0* Open2L194C77){ +T0* c0=(u->c0); +T6 c1=(u->c1); +r69proximity(((T69*)u->c0),(T6)(0),Open2L194C77); +}/*--*/ + +/*agent creation*/T0*agenT25C25l194c40(T0* c0,T6 c1){ +se_agenT25C25l194c40*u=(void*)new_agent(202); +u->creation_mold_id=0; +u->afp=_agenT25C25l194c40; +u->eq=eq_agent_eqC69C6_r69proximity; +u->gc_mark_agent_mold=gc_mark_agenT25C25l194c40; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l194c40(se_agenT25C25l194c40*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC69C6_r69proximity(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC69C6_r69proximity*a1=(se_agent_eqC69C6_r69proximity*)u1; +se_agent_eqC69C6_r69proximity*a2=(se_agent_eqC69C6_r69proximity*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l193c39(se_agenT25C25l193c39*u,T0* Open2L193C75){ +T0* c0=(u->c0); +T6 c1=(u->c1); +r69proximity(((T69*)u->c0),(T6)(1),Open2L193C75); +}/*--*/ + +/*agent creation*/T0*agenT25C25l193c39(T0* c0,T6 c1){ +se_agenT25C25l193c39*u=(void*)new_agent(202); +u->creation_mold_id=1; +u->afp=_agenT25C25l193c39; +u->eq=eq_agent_eqC69C6_r69proximity; +u->gc_mark_agent_mold=gc_mark_agenT25C25l193c39; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l193c39(se_agenT25C25l193c39*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +} +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l192c42(se_agenT25C25l192c42*u,T0* Open2L192C76){ +T0* c0=(u->c0); +T6 c1=(u->c1); +r69button(((T69*)u->c0),(T6)(0),Open2L192C76); +}/*--*/ + +/*agent creation*/T0*agenT25C25l192c42(T0* c0,T6 c1){ +se_agenT25C25l192c42*u=(void*)new_agent(202); +u->creation_mold_id=2; +u->afp=_agenT25C25l192c42; +u->eq=eq_agent_eqC69C6_r69button; +u->gc_mark_agent_mold=gc_mark_agenT25C25l192c42; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l192c42(se_agenT25C25l192c42*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC69C6_r69button(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC69C6_r69button*a1=(se_agent_eqC69C6_r69button*)u1; +se_agent_eqC69C6_r69button*a2=(se_agent_eqC69C6_r69button*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l191c41(se_agenT25C25l191c41*u,T0* Open2L191C74){ +T0* c0=(u->c0); +T6 c1=(u->c1); +r69button(((T69*)u->c0),(T6)(1),Open2L191C74); +}/*--*/ + +/*agent creation*/T0*agenT25C25l191c41(T0* c0,T6 c1){ +se_agenT25C25l191c41*u=(void*)new_agent(202); +u->creation_mold_id=3; +u->afp=_agenT25C25l191c41; +u->eq=eq_agent_eqC69C6_r69button; +u->gc_mark_agent_mold=gc_mark_agenT25C25l191c41; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l191c41(se_agenT25C25l191c41*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +} +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l190c32(se_agenT25C25l190c32*u,T0* Open1L190C52){ +T0* c0=(u->c0); +r69move(((T69*)u->c0),Open1L190C52); +}/*--*/ + +/*agent creation*/T0*agenT25C25l190c32(T0* c0){ +se_agenT25C25l190c32*u=(void*)new_agent(202); +u->creation_mold_id=4; +u->afp=_agenT25C25l190c32; +u->eq=eq_agent_eqC69_r69move; +u->gc_mark_agent_mold=gc_mark_agenT25C25l190c32; +u->c0=c0; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l190c32(se_agenT25C25l190c32*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC69_r69move(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC69_r69move*a1=(se_agent_eqC69_r69move*)u1; +se_agent_eqC69_r69move*a2=(se_agent_eqC69_r69move*)u2; +R&=a1->c0==a2->c0; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l173c38(se_agenT25C25l173c38*u,T0* Open2L173C80){ +T0* c0=(u->c0); +T0* c1=(u->c1); +r25pad_button_released(((T25*)u->c0),u->c1,Open2L173C80); +}/*--*/ + +/*agent creation*/T0*agenT25C25l173c38(T0* c0,T0* c1){ +se_agenT25C25l173c38*u=(void*)new_agent(202); +u->creation_mold_id=5; +u->afp=_agenT25C25l173c38; +u->eq=eq_agent_eqC25C7_r25pad_button_released; +u->gc_mark_agent_mold=gc_mark_agenT25C25l173c38; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l173c38(se_agenT25C25l173c38*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +gc_mark(u->c1); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC25C7_r25pad_button_released(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC25C7_r25pad_button_released*a1=(se_agent_eqC25C7_r25pad_button_released*)u1; +se_agent_eqC25C7_r25pad_button_released*a2=(se_agent_eqC25C7_r25pad_button_released*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l172c37(se_agenT25C25l172c37*u,T0* Open2L172C78){ +T0* c0=(u->c0); +T0* c1=(u->c1); +r25pad_button_pressed(((T25*)u->c0),u->c1,Open2L172C78); +}/*--*/ + +/*agent creation*/T0*agenT25C25l172c37(T0* c0,T0* c1){ +se_agenT25C25l172c37*u=(void*)new_agent(202); +u->creation_mold_id=6; +u->afp=_agenT25C25l172c37; +u->eq=eq_agent_eqC25C7_r25pad_button_pressed; +u->gc_mark_agent_mold=gc_mark_agenT25C25l172c37; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l172c37(se_agenT25C25l172c37*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +gc_mark(u->c1); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC25C7_r25pad_button_pressed(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC25C7_r25pad_button_pressed*a1=(se_agent_eqC25C7_r25pad_button_pressed*)u1; +se_agent_eqC25C7_r25pad_button_pressed*a2=(se_agent_eqC25C7_r25pad_button_pressed*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l167c36(se_agenT25C25l167c36*u,T0* Open2L167C74){ +T0* c0=(u->c0); +T0* c1=(u->c1); +r25left_slider_out(((T25*)u->c0),u->c1,Open2L167C74); +}/*--*/ + +/*agent creation*/T0*agenT25C25l167c36(T0* c0,T0* c1){ +se_agenT25C25l167c36*u=(void*)new_agent(202); +u->creation_mold_id=7; +u->afp=_agenT25C25l167c36; +u->eq=eq_agent_eqC25C7_r25left_slider_out; +u->gc_mark_agent_mold=gc_mark_agenT25C25l167c36; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l167c36(se_agenT25C25l167c36*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +gc_mark(u->c1); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC25C7_r25left_slider_out(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC25C7_r25left_slider_out*a1=(se_agent_eqC25C7_r25left_slider_out*)u1; +se_agent_eqC25C7_r25left_slider_out*a2=(se_agent_eqC25C7_r25left_slider_out*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + + +/*agent launcher*/static void _agenT25C25l166c28(se_agenT25C25l166c28*u,T0* Open2L166C63){ +T0* c0=(u->c0); +T0* c1=(u->c1); +r25slider_event(((T25*)u->c0),u->c1,Open2L166C63); +}/*--*/ + +/*agent creation*/T0*agenT25C25l166c28(T0* c0,T0* c1){ +se_agenT25C25l166c28*u=(void*)new_agent(202); +u->creation_mold_id=8; +u->afp=_agenT25C25l166c28; +u->eq=eq_agent_eqC25C7_r25slider_event; +u->gc_mark_agent_mold=gc_mark_agenT25C25l166c28; +u->c0=c0; +u->c1=c1; +return((T0*)u); +}/*--*/ + +void gc_mark_agenT25C25l166c28(se_agenT25C25l166c28*u){ +gc_agent*gcu=(gc_agent*)u; +if (gcu->header.flag==FSOH_UNMARKED){ +gcu->header.flag=FSOH_MARKED; +gc_mark(u->c0); +gc_mark(u->c1); +} +}/*--*/ + +/*agent equality*/int eq_agent_eqC25C7_r25slider_event(se_agent*u1, se_agent*u2){ +int R=1; +se_agent_eqC25C7_r25slider_event*a1=(se_agent_eqC25C7_r25slider_event*)u1; +se_agent_eqC25C7_r25slider_event*a2=(se_agent_eqC25C7_r25slider_event*)u2; +R&=a1->c0==a2->c0; +R&=a1->c1==a2->c1; +return R; +}/*--*/ + +/*XINPUT_IVY*/T0* r25std_output(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC13std_output==0){fBC13std_output=1;{ +tmp0=((T0*)(new53())); +r53make(((T53*)tmp0)); +oBC13std_output=tmp0; +}} +return oBC13std_output; +}/*--*/ + +/*XINPUT_IVY*/T0* r25vision(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +if(fBC26vision==0){fBC26vision=1;{ +tmp0=((T0*)(new64())); +r64graphic_init(((T64*)tmp0)); +oBC26vision=tmp0; +}} +return oBC26vision; +}/*--*/ + +/*XINPUT_IVY*/T6 r25decode_options(T25* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T6 R=0; +T2 _i=0; +T0* _option=(void*)0; +T0* _value=(void*)0; +T2 _equal_index=0; +T6 _error=0; +T0* _tmp_pointer=(void*)0; +T0* _0; /* string inspect expression */ /*l64c5/xinput_ivy.e*/ +T2 _1; /* string inspect state */ /*l64c5/xinput_ivy.e*/ +/*l47c4/xinput_ivy.e*/ +/*l48c5/xinput_ivy.e*/ +_i=INT32_C(1); +/*l49c5/xinput_ivy.e*/ +_option=se_ms(0,s25_0); +/*l50c5/xinput_ivy.e*/ +_value=se_ms(0,s25_0); +/*l51c5/xinput_ivy.e*/ +tmp0=((T0*)(new69())); +r69make(((T69*)tmp0),(T0*)C); +_tmp_pointer=tmp0; +while (!(r6_ix_or((T6)(((int32_t)(_i))>(r25argument_count())),(T6)(_error)))) +{ +/*l55c12/xinput_ivy.e*/ +r7copy(((T7*)_option),((/*RF2*/((T204*)(r25command_arguments()))->_storage/*3p*/))[_i]); +/*l56c5/xinput_ivy.e*/ +_equal_index=r7first_index_of(((T7*)_option),((T3)'\075')); +/*l57c5/xinput_ivy.e*/ +if((_equal_index)==(INT8_C(0))){ +(/*RF2*/(((T7*)_value))->_count/*3p*/)=INT32_C(0); +} +else{ +/*l60c12/xinput_ivy.e*/ +r7copy(((T7*)_value),_option); +/*l61c12/xinput_ivy.e*/ +r7remove_head(((T7*)_value),_equal_index); +/*l62c13/xinput_ivy.e*/ +r7remove_tail(((T7*)_option),((int32_t)(((int32_t)((/*RF2*/(((T7*)_option))->_count/*3p*/)))-(_equal_index)))+(INT32_C(1))); +} +/*l64c5/xinput_ivy.e*/ +_0=_option; +/*l64c5/xinput_ivy.e*/ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(0)])==(((T3)'\055'))){ +/*[INSPECT*/ +{int inspect_tmp_1=((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(1)]; +switch(inspect_tmp_1){ +case 104: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'l'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'p'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(5))){ +_1=INT8_C(1); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 108: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'s'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'t'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'\137'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'d'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'v'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(9)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(10)])==(((T3)'c'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(11)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(12)])==(((T3)'s'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(13))){ +_1=INT8_C(2); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 112: +/*[INSPECT*/ +{int inspect_tmp_2=((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)]; +switch(inspect_tmp_2){ +case 97: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'d'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(4))){ +_1=INT8_C(3); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 114: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'d'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'c'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'t'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(9)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(10)])==(((T3)'n'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(11))){ +_1=INT8_C(11); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +default:; +_1=INT8_C(0); +} +}/*INSPECT]*/ +break; +case 119: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'a'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'c'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'m'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'\137'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'p'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(9)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(10)])==(((T3)'n'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(11)])==(((T3)'t'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(12)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(13)])==(((T3)'r'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(14))){ +_1=INT8_C(4); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 98: +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(2))){ +_1=INT8_C(6); +} +else{ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'u'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'s'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(4))){ +_1=INT8_C(5); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +break; +case 97: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'p'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'p'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'l'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'c'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'a'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'t'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(9)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(10)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(11)])==(((T3)'n'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(12))){ +_1=INT8_C(7); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 105: +/*[INSPECT*/ +{int inspect_tmp_2=((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)]; +switch(inspect_tmp_2){ +case 100: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'n'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'t'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'f'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'i'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(9)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(10)])==(((T3)'r'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(11))){ +_1=INT8_C(8); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 103: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'n'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'r'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'e'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(7))){ +_1=INT8_C(12); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +default:; +_1=INT8_C(0); +} +}/*INSPECT]*/ +break; +case 120: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'\137'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'f'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'f'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'s'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'t'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(9))){ +_1=INT8_C(9); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +case 121: +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(2)])==(((T3)'\137'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(3)])==(((T3)'o'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(4)])==(((T3)'f'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(5)])==(((T3)'f'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(6)])==(((T3)'s'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(7)])==(((T3)'e'))){ +if((((/*RF2*/(((T7*)_0))->_storage/*3p*/))[INT32_C(8)])==(((T3)'t'))){ +if(((/*RF2*/(((T7*)_0))->_count/*3p*/))==(INT8_C(9))){ +_1=INT8_C(10); +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +} +else{ +_1=INT8_C(0); +} +break; +default:; +_1=INT8_C(0); +} +}/*INSPECT]*/ +} +else{ +_1=INT8_C(0); +} +/*l64c5/xinput_ivy.e*/ +/*[INSPECT*/ +{int inspect_tmp_1=_1; +switch(inspect_tmp_1){ +case 1: +r25print_help(); +break; +case 2: +r25list_devices(C); +break; +case 3: +if(r25init_pad(C,_value)){ +R=((T6)(1)); +} +else{ +/*l73c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l75c17/xinput_ivy.e*/ +r43put_string(_value); +/*l76c17/xinput_ivy.e*/ +r43put_string(se_ms(27,s25_69208946)); +} +break; +case 4: +if(r25init_wacom_pointer(C,_tmp_pointer,_value)){ +R=((T6)(1)); +} +else{ +/*l82c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l84c17/xinput_ivy.e*/ +r43put_string(_value); +/*l85c17/xinput_ivy.e*/ +r43put_string(se_ms(31,s25_447643634)); +} +break; +case 5: +r7copy((T7*)((/*RF2*/(C)->_ivy_bus/*8p*/)),_value); +break; +case 6: +if(((int32_t)(_i))<(r25argument_count())){ +/*l91c7/xinput_ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +/*l92c15/xinput_ivy.e*/ +r7copy((T7*)((/*RF2*/(C)->_ivy_bus/*8p*/)),((/*RF2*/((T204*)(r25command_arguments()))->_storage/*3p*/))[_i]); +} +else{ +/*l94c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l95c17/xinput_ivy.e*/ +r43put_string(se_ms(40,s25_1554692325)); +} +break; +case 7: +r7copy((T7*)((/*RF2*/(C)->_application_name/*8p*/)),_value); +break; +case 8: +r7copy((T7*)((/*RF2*/(C)->_device_id/*8p*/)),_value); +break; +case 9: +if(r7is_integer(((T7*)_value))){ +(/*RF2*/(((T69*)_tmp_pointer))->_x_offset/*25p*/)=r7to_integer(((T7*)_value)); +} +else{ +/*l106c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l108c17/xinput_ivy.e*/ +r43put_string(_value); +/*l109c17/xinput_ivy.e*/ +r43put_string(se_ms(50,s25_1491411490)); +} +break; +case 10: +if(r7is_integer(((T7*)_value))){ +(/*RF2*/(((T69*)_tmp_pointer))->_y_offset/*25p*/)=r7to_integer(((T7*)_value)); +} +else{ +/*l115c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l117c17/xinput_ivy.e*/ +r43put_string(_value); +/*l118c17/xinput_ivy.e*/ +r43put_string(se_ms(50,s25_751291742)); +} +break; +case 11: +if(r7is_real(((T7*)_value))){ +(/*RF2*/(((T69*)_tmp_pointer))->_prediction_time/*25p*/)=r7to_real(((T7*)_value)); +} +else{ +/*l124c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l126c17/xinput_ivy.e*/ +r43put_string(_value); +/*l127c17/xinput_ivy.e*/ +r43put_string(se_ms(49,s25_357338863)); +} +break; +case 12: +if(r7is_integer(((T7*)_value))){ +(/*RF2*/(((T69*)_tmp_pointer))->_ignore_rate/*25p*/)=r7to_integer(((T7*)_value)); +} +else{ +/*l133c7/xinput_ivy.e*/ +_error=((T6)(1)); +/*l37c4/std_error.e*/ +io_putc(((T3)'\042'),(stderr)); +/*l135c17/xinput_ivy.e*/ +r43put_string(_value); +/*l136c17/xinput_ivy.e*/ +r43put_string(se_ms(53,s25_382517595)); +} +break; +default:; +/*l139c6/xinput_ivy.e*/ +_error=((T6)(1)); +/*l140c16/xinput_ivy.e*/ +r43put_string(se_ms(15,s25_1260406502)); +/*l141c16/xinput_ivy.e*/ +r43put_string(((/*RF2*/((T204*)(r25command_arguments()))->_storage/*3p*/))[_i]); +/*l37c4/std_error.e*/ +io_putc(((T3)'\n'),(stderr)); +/*l143c6/xinput_ivy.e*/ +r25print_help(); +} +}/*INSPECT]*/ +/*l145c5/xinput_ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +/*l147c4/xinput_ivy.e*/ +if(_error){ +R=((T6)(0)); +} +/*l150c4/xinput_ivy.e*/ +if((r25argument_count())==(INT8_C(0))){ +r25print_help(); +} +return R; +}/*--*/ + +/*XINPUT_IVY*/void r25list_devices(T25* C){ +T2 _i=0; +T0* _devices=(void*)0; +T0* _device=(void*)0; +if((r143has_x_input_extension())==(0)){ +r43put_line(se_ms(33,s25_1213754110)); +} +else{ +/*l403c6/xinput_ivy.e*/ +_devices=(/*RF2*/((T175*)(r143x_input_extension()))->_devices/*p*/); +/*l404c6/xinput_ivy.e*/ +_i=INT32_C(0); +while (!(((int32_t)(_i))>((/*RF2*/(((T205*)_devices))->_upper/*3p*/)))) +{ +/*l408c6/xinput_ivy.e*/ +_device=((/*RF2*/(((T205*)_devices))->_storage/*3p*/))[_i]; +/*l409c17/xinput_ivy.e*/ +r53put_string((T53*)(r25std_output()),(/*RF2*/(((T67*)_device))->_name/*14p*/)); +/*l410c17/xinput_ivy.e*/ +r53put_string((T53*)(r25std_output()),ms25_3479972); +/*l411c6/xinput_ivy.e*/ +if(((/*RF2*/(((T67*)_device))->_type/*14p*/))==((void*)((void*)0))){ +r53filtered_put_character((T53*)(r25std_output()),((T3)'\077')); +} +else{ +r53put_string((T53*)(r25std_output()),(/*RF2*/(((T67*)_device))->_type/*14p*/)); +} +/*l416c17/xinput_ivy.e*/ +r53put_string((T53*)(r25std_output()),ms25_21190322); +/*l417c6/xinput_ivy.e*/ +if((/*RF2*/(((T67*)_device))->_is_available_extension/*14p*/)){ +r53put_line((T53*)(r25std_output()),ms25_557679246); +} +else{ +r53put_line((T53*)(r25std_output()),ms25_1959886733); +} +/*l422c6/xinput_ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +}/*--*/ + +/*XINPUT_IVY*/void r25print_help(void){ +r46put_string(se_ms(4135,s25_703548632)); +}/*--*/ + +/*XINPUT_IVY*/T6 r25init_pad(T25* C,T0* a1){ +T6 R=0; +T0* _pad=(void*)0; +T0* _message_header=(void*)0; +/*l160c4/xinput_ivy.e*/ +_pad=r25subscribe_input(C,a1); +/*l161c4/xinput_ivy.e*/ +if((_pad)!=((void*)((void*)0))){ +/*l162c5/xinput_ivy.e*/ +R=((T6)(1)); +/*l163c5/xinput_ivy.e*/ +_message_header=se_ms(23,s25_1948078333); +/*l164c20/xinput_ivy.e*/ +r7append(((T7*)_message_header),(/*RF2*/(C)->_device_id/*8p*/)); +/*l165c20/xinput_ivy.e*/ +r7append(((T7*)_message_header),ms25_946366); +/*l166c9/xinput_ivy.e*/ +r67when_moved(((T67*)_pad),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l166c28((T0*)C,_message_header)); +/*l167c9/xinput_ivy.e*/ +r67when_proximity_out(((T67*)_pad),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l167c36((T0*)C,_message_header)); +/*l169c5/xinput_ivy.e*/ +_message_header=se_ms(20,s25_1666922512); +/*l170c20/xinput_ivy.e*/ +r7append(((T7*)_message_header),(/*RF2*/(C)->_device_id/*8p*/)); +/*l171c20/xinput_ivy.e*/ +r7append(((T7*)_message_header),ms25_4487261); +/*l172c9/xinput_ivy.e*/ +r67when_button_pressed(((T67*)_pad),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l172c37((T0*)C,_message_header)); +/*l173c9/xinput_ivy.e*/ +r67when_button_released(((T67*)_pad),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l173c38((T0*)C,_message_header)); +} +return R; +}/*--*/ + +/*XINPUT_IVY*/void r25left_slider_out(T25* C,T0* a1,T0* a2){ +T0* _message=(void*)0; +/*l360c4/xinput_ivy.e*/ +_message=ms25_0bc25c15l360; +/*l361c12/xinput_ivy.e*/ +r7copy(((T7*)_message),a1); +/*l362c12/xinput_ivy.e*/ +r7extend(((T7*)_message),((T3)'0')); +/*l363c12/xinput_ivy.e*/ +r7append(((T7*)_message),ms25_1403610646bc25); +/*l364c19/xinput_ivy.e*/ +r2append_in(x_device_event_time,_message); +/*l365c8/xinput_ivy.e*/ +r70send_message((T70*)((/*RF2*/(C)->_ivy/*8p*/)),_message); +/*l366c4/xinput_ivy.e*/ +/*SFN*/(C->_left_pad_position/*8p*/)=INT32_C(0); +}/*--*/ + +/*XINPUT_IVY*/void r25pad_button_pressed(T25* C,T0* a1,T0* a2){ +T0* _message=(void*)0; +/*l373c4/xinput_ivy.e*/ +_message=ms25_0bc25c15; +/*l374c12/xinput_ivy.e*/ +r7copy(((T7*)_message),a1); +/*l375c22/xinput_ivy.e*/ +r2append_in(x_device_button_event_number,_message); +/*l376c12/xinput_ivy.e*/ +r7append(((T7*)_message),ms25_694149733); +/*l377c19/xinput_ivy.e*/ +r2append_in(x_device_event_time,_message); +/*l378c8/xinput_ivy.e*/ +r70send_message((T70*)((/*RF2*/(C)->_ivy/*8p*/)),_message); +}/*--*/ + +/*XINPUT_IVY*/void r25pad_button_released(T25* C,T0* a1,T0* a2){ +T0* _message=(void*)0; +/*l385c4/xinput_ivy.e*/ +_message=ms25_0bc25; +/*l386c12/xinput_ivy.e*/ +r7copy(((T7*)_message),a1); +/*l387c22/xinput_ivy.e*/ +r2append_in(x_device_button_event_number,_message); +/*l388c12/xinput_ivy.e*/ +r7append(((T7*)_message),ms25_314746909); +/*l389c19/xinput_ivy.e*/ +r2append_in(x_device_event_time,_message); +/*l390c8/xinput_ivy.e*/ +r70send_message((T70*)((/*RF2*/(C)->_ivy/*8p*/)),_message); +}/*--*/ + +/*XINPUT_IVY*/T2 r25argument_count(void){ +T2 R=0; +R=(/*RF2*/((T204*)(r25command_arguments()))->_upper/*3p*/); +return R; +}/*--*/ + +/*XINPUT_IVY*/void r25make(T25* C){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T6 _ready=0; +/*l24c4/xinput_ivy.e*/ +/*SFN*/(C->_application_name/*8p*/)=se_ms(5,s25_89639); +/*l25c4/xinput_ivy.e*/ +/*SFN*/(C->_ivy_bus/*8p*/)=se_ms(5,s25_44143); +/*l26c4/xinput_ivy.e*/ +/*SFN*/(C->_device_id/*8p*/)=se_ms(7,s25_1957581); +/*l27c4/xinput_ivy.e*/ +/*SFN*/(C->_screen/*8p*/)=((/*UT*/(void)((T64*)(r25vision()))),r64root_window()); +/*l28c4/xinput_ivy.e*/ +_ready=((T6)(r25decode_options(C))); +/*l29c4/xinput_ivy.e*/ +if(_ready){ +/*l30c5/xinput_ivy.e*/ +tmp0=((T0*)(new70())); +r70make(((T70*)tmp0),(/*RF2*/(C)->_application_name/*8p*/)); +/*SFN*/(C->_ivy/*8p*/)=tmp0; +/*l31c9/xinput_ivy.e*/ +r70start((T70*)((/*RF2*/(C)->_ivy/*8p*/)),(/*RF2*/(C)->_ivy_bus/*8p*/)); +/*l32c23/xinput_ivy.e*/ +r130add_job((T130*)((/*RF2*/((T64*)(r25vision()))->_loop_stack/*6p*/)),(/*RF2*/(C)->_ivy/*8p*/)); +/*l33c12/xinput_ivy.e*/ +r64start((T64*)(r25vision())); +} +}/*--*/ + +/*XINPUT_IVY*/T0* r25subscribe_input(T25* C,T0* a1){ +T0* R=(void*)0; +T2 _i=0; +T0* _devices=(void*)0; +if((r143has_x_input_extension())==(0)){ +r43put_line(se_ms(33,s25_1213754110)); +} +else{ +/*l308c6/xinput_ivy.e*/ +_devices=(/*RF2*/((T175*)(r143x_input_extension()))->_devices/*p*/); +/*l309c6/xinput_ivy.e*/ +_i=INT32_C(0); +while (!((T6)((((int32_t)(_i))>((/*RF2*/(((T205*)_devices))->_upper/*3p*/)))||((T6)((R)!=((void*)((void*)0))))))) +{ +/*l313c6/xinput_ivy.e*/ +if(r7is_equal((T7*)((/*RF2*/((T67*)(((/*RF2*/(((T205*)_devices))->_storage/*3p*/))[_i]))->_name/*14p*/)),a1)){ +/*l314c7/xinput_ivy.e*/ +R=((/*RF2*/(((T205*)_devices))->_storage/*3p*/))[_i]; +/*l315c7/xinput_ivy.e*/ +if((/*RF2*/(((T67*)R))->_is_available_extension/*14p*/)){ +r67connect(((T67*)R)); +} +else{ +R=(void*)0; +} +} +/*l321c6/xinput_ivy.e*/ +_i=((int32_t)(_i))+(INT32_C(1)); +} +} +return R; +}/*--*/ + +/*XINPUT_IVY*/T6 r25init_wacom_pointer(T25* C,T0* a1,T0* a2){ +T6 R=0; +T0* _pointer=(void*)0; +T0* _message_header=(void*)0; +T0* _wacom_pointer=(void*)0; +/*l183c4/xinput_ivy.e*/ +_pointer=r25subscribe_input(C,a2); +/*l184c4/xinput_ivy.e*/ +if((_pointer)!=((void*)((void*)0))){ +/*l185c5/xinput_ivy.e*/ +R=((T6)(1)); +/*l186c5/xinput_ivy.e*/ +_wacom_pointer=r69twin(((T69*)a1)); +/*l187c5/xinput_ivy.e*/ +_message_header=se_ms(17,s25_765567725); +/*l188c20/xinput_ivy.e*/ +r7append(((T7*)_message_header),(/*RF2*/(C)->_device_id/*8p*/)); +/*l189c19/xinput_ivy.e*/ +r69set_message_header(((T69*)_wacom_pointer),_message_header); +/*l190c13/xinput_ivy.e*/ +r67when_moved(((T67*)_pointer),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l190c32(_wacom_pointer)); +/*l191c13/xinput_ivy.e*/ +r67when_button_pressed(((T67*)_pointer),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l191c41(_wacom_pointer,1)); +/*l192c13/xinput_ivy.e*/ +r67when_button_released(((T67*)_pointer),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l192c42(_wacom_pointer,0)); +/*l193c13/xinput_ivy.e*/ +r67when_proximity_in(((T67*)_pointer),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l193c39(_wacom_pointer,1)); +/*l194c13/xinput_ivy.e*/ +r67when_proximity_out(((T67*)_pointer),(/*RF2*/(C)->_screen/*8p*/),agenT25C25l194c40(_wacom_pointer,0)); +} +return R; +}/*--*/ + +/*XINPUT_IVY*/void r25slider_event(T25* C,T0* a1,T0* a2){ +T2 _new_pad_position=0; +T0* _message=(void*)0; +/*l334c4/xinput_ivy.e*/ +_message=ms25_0; +/*l335c4/xinput_ivy.e*/ +_new_pad_position=r67motion_axis_data(INT32_C(4)); +/*l336c4/xinput_ivy.e*/ +if((_new_pad_position)!=((/*RF2*/(C)->_left_pad_position/*8p*/))){ +/*l337c13/xinput_ivy.e*/ +r7copy(((T7*)_message),a1); +/*l338c22/xinput_ivy.e*/ +r2append_in(_new_pad_position,_message); +/*l339c13/xinput_ivy.e*/ +r7append(((T7*)_message),ms25_1403610646); +/*l340c20/xinput_ivy.e*/ +r2append_in(x_device_event_time,_message); +/*l341c9/xinput_ivy.e*/ +r70send_message((T70*)((/*RF2*/(C)->_ivy/*8p*/)),_message); +/*l342c5/xinput_ivy.e*/ +/*SFN*/(C->_left_pad_position/*8p*/)=_new_pad_position; +} +/*l345c4/xinput_ivy.e*/ +_new_pad_position=r67motion_axis_data(INT32_C(5)); +/*l346c4/xinput_ivy.e*/ +if((_new_pad_position)!=((/*RF2*/(C)->_right_pad_position/*8p*/))){ +/*l347c13/xinput_ivy.e*/ +r7copy(((T7*)_message),a1); +/*l348c22/xinput_ivy.e*/ +r2append_in(_new_pad_position,_message); +/*l349c13/xinput_ivy.e*/ +r7append(((T7*)_message),ms25_1638797568); +/*l350c20/xinput_ivy.e*/ +r2append_in(x_device_event_time,_message); +/*l351c9/xinput_ivy.e*/ +r70send_message((T70*)((/*RF2*/(C)->_ivy/*8p*/)),_message); +/*l352c5/xinput_ivy.e*/ +/*SFN*/(C->_right_pad_position/*8p*/)=_new_pad_position; +} +}/*--*/ +T0*oBC30command_arguments=(void*)0; +int fBC30command_arguments=0; + +/*XINPUT_IVY*/T0* r25command_arguments(void){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +T2 _i=0; +T0* _arg=(void*)0; +if(fBC30command_arguments==0){fBC30command_arguments=1;{ +/*l44c5/arguments.e*/ +_i=se_argc; +/*l45c5/arguments.e*/ +tmp0=((T0*)(new204())); +r204make(((T204*)tmp0),_i); +oBC30command_arguments=tmp0; +while (!((_i)==(INT8_C(0)))) +{ +/*l49c5/arguments.e*/ +_i=((int32_t)(_i))-(INT32_C(1)); +/*l50c5/arguments.e*/ +_arg=((T0*)se_string(se_argv[_i])); +/*l122c12/fast_array.e*/ +((/*RF2*/(((T204*)oBC30command_arguments))->_storage/*3p*/))[_i]=(_arg); +} +}} +return oBC30command_arguments; +}/*--*/ + +void agent_launcher(/*agent*/T0*a){ +/*PROCEDURE[TUPLE]*/switch(((se_agent0*)a)->creation_mold_id){ +} +}/*--*/ + +void agent_launcher_FAST_ARRAY__STRING__(/*agent*/T0*a,T0* a1){ +/*PROCEDURE[TUPLE[FAST_ARRAY[STRING]]]*/switch(((se_agent0*)a)->creation_mold_id){ +} +}/*--*/ + +void agent_launcher_INTEGER_32_INTEGER_32(/*agent*/T0*a,T2 a1,T2 a2){ +/*PROCEDURE[TUPLE[INTEGER_32,INTEGER_32]]*/switch(((se_agent0*)a)->creation_mold_id){ +} +}/*--*/ + +void agent_launcher_INTEGER_32_INTEGER_32_INTEGER_32_INTEGER_32(/*agent*/T0*a,T2 a1,T2 a2,T2 a3,T2 a4){ +/*PROCEDURE[TUPLE[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32]]*/switch(((se_agent0*)a)->creation_mold_id){ +} +}/*--*/ + +void agent_launcher_X_INPUT_DEVICE(/*agent*/T0*a,T0* a1){ +/*PROCEDURE[TUPLE[X_INPUT_DEVICE]]*/switch(((se_agent0*)a)->creation_mold_id){ +case 0:{ +((se_agenT25C25l194c40*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 1:{ +((se_agenT25C25l193c39*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 2:{ +((se_agenT25C25l192c42*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 3:{ +((se_agenT25C25l191c41*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 4:{ +((se_agenT25C25l190c32*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 5:{ +((se_agenT25C25l173c38*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 6:{ +((se_agenT25C25l172c37*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 7:{ +((se_agenT25C25l167c36*)a)->afp(((/*agent*/void*)a),a1); +break; +} +case 8:{ +((se_agenT25C25l166c28*)a)->afp(((/*agent*/void*)a),a1); +break; +} +} +}/*--*/ +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef SE_GC_LIB +gc_agent *store_agent = NULL; +gc_agent *gc_free_agent = NULL; +int store_left_agent = 0; +int count_agent=0; +int gc_info_nb_agent = 0; +fsoc *store_chunk_agent = NULL; +fsoc H_agent = +{ + { + FSOC_SIZE, FSO_STORE_CHUNK, + (void (*)(mch *, void *)) gc_align_mark_agent, + (void (*)(mch *)) gc_sweep_agent + }, + NULL, + (((FSOC_SIZE - sizeof (fsoc) + sizeof (double)) / sizeof (gc_agent)) - 1) +}; +#endif + +se_agent* new_agent(Tid id) { +#ifdef SE_GC_LIB + int i; + gc_agent *agent; + fsoc *c; + if (store_left_agent > 1) + { + store_left_agent--; + agent = store_agent++; + } + else if (gc_free_agent != NULL) + { + agent = gc_free_agent; + gc_free_agent = agent->header.next; + } + else if (store_left_agent == 1) + { + store_left_agent = 0; + store_chunk_agent->header.state_type = FSO_USED_CHUNK; + agent = store_agent++; + } + else + { + c = gc_fsoc_get1 (); + if (c == NULL) + c = gc_fsoc_get2 (); + store_chunk_agent = c; + *store_chunk_agent = H_agent; + store_agent = ((gc_agent *) (&(store_chunk_agent->first_object))); + store_left_agent = H_agent.count_minus_one; + agent = store_agent++; + } + agent->header.flag = FSOH_UNMARKED; + for(i=0;i<(sizeof(se_agent)/sizeof(int));i++) + ((int*) (agent))[i] = 0; + +#else /* SE_GC_LIB */ + se_agent* agent = se_calloc(1,sizeof(se_agent)); + +#endif /* SE_GC_LIB */ + + ((se_agent*) agent)->u0.id = id; + +#ifdef SE_GC_LIB + gc_info_nb_agent++; +#endif /* SE_GC_LIB */ + return (se_agent *) agent; +} + + +#ifdef SE_GC_LIB +void gc_sweep_agent (fsoc * c) { + gc_agent *a1, *a2, *flt, flh; + a1 = ((gc_agent *) (&(c->first_object))); + if (c->header.state_type == FSO_STORE_CHUNK) { + for (; a1 < store_agent; a1++) { + if ((a1->header.flag) == FSOH_MARKED) { + a1->header.flag = FSOH_UNMARKED; + } + else if ((a1->header.flag) == FSOH_UNMARKED) { + a1->header.next = gc_free_agent; + gc_free_agent = a1; + } + } + } + else { + int dead = 1; + flh.header.next = NULL; + flt = &flh; + a2 = a1 + c->count_minus_one; + for (; a1 <= a2; a2--) { + if ((a2->header.flag) == FSOH_MARKED) { + a2->header.flag = FSOH_UNMARKED; + dead = 0; + } + else if ((a2->header.flag) == FSOH_UNMARKED) { + flt->header.next = a2; + flt = a2; + } + } + if (dead) { + gc_agent **prvnxt=&gc_free_agent; + char *inf=(char*)((gc_agent*)(&(c->first_object))); + char *sup=(char*)(((gc_agent*)(&(c->first_object)))+c->count_minus_one); + a1=gc_free_agent; + while(a1!=NULL) { + if(inf>(char*)a1 || (char*)a1>sup) { + *prvnxt=a1; + prvnxt=&a1->header.next; + } + a1=a1->header.next; + } + *prvnxt=NULL; + c->next = fsocfl; + fsocfl = c; + c->header.state_type = FSO_FREE_CHUNK; + } + else if (flh.header.next != NULL) { + flt->header.next = gc_free_agent; + gc_free_agent = flh.header.next; + } + } +} + +void gc_align_mark_agent (fsoc * c, gc_agent * p) { + gc_agent *b = ((gc_agent *) (&(c->first_object))); + if ((c->header.state_type == FSO_STORE_CHUNK) + && (((char *) p) >= ((char *) store_agent))) + return; + + if (((char *) p) > ((char *) (b + (c->count_minus_one)))) + return; + + if (((char *) p) < ((char *) b)) + return; + if (((((char *) p) - ((char *) b)) % sizeof (*p)) == 0) + { + se_agent *ta = (&(p->object)); + (*(ta->u0.gc_mark_agent_mold))(ta); + } +} + +#endif /* SE_GC_LIB */ +T0*ms69_1874520032; +T0*ms25_0bc25c15l360; +T0*ms69_22702416; +T0*ms69_22702411; +T0*ms69_190991; +T0*ms143_1472358418; +T0*ms69_15980; +T0*ms25_0bc25; +T0*ms69_188916; +T0*ms25_0bc69; +T0*ms25_0bc69c15l93; +T0*ms69_1501987274; +T0*ms25_1403610646; +T0*ms25_0; +T0*ms69_10739030; +T0*ms69_10739024; +T0*ms69_10739017; +T0*ms25_1959886733; +T0*ms25_0bc25c15; +T0*ms25_3479972; +T0*ms25_21190322; +T0*ms69_1756148648; +T0*ms69_1756148653; +T0*ms69_1619665677; +T0*ms69_104371129; +T0*ms69_104371267; +T0*ms25_314746909; +T0*ms25_1638797568; +T0*ms69_1961093439; +T0*ms69_1699147265; +T0*ms69_23436791; +T0*ms25_4487261bc69; +T0*ms25_694149733; +T0*ms69_4738061; +T0*ms69_2112369621; +T0*ms25_557679246; +T0*ms69_1940108584; +T0*ms69_952626; +T0*ms69_1461; +T0*ms69_1466; +T0*ms69_4725666; +T0*ms69_4725661; +T0*ms69_56246305; +T0*ms69_2676; +T0*ms25_4487261; +T0*ms69_1257860908; +T0*ms69_56246305bc69; +T0*ms25_1403610646bc25; +T0*ms69_2057747851; +T0*ms25_0bc69c16; +T0*ms25_0bc69c15; +T0*ms69_586741066; +T0*ms25_946366; +T0*ms69_475; +T0*ms69_697; + +T0*se_ms(int c,char*e){ +/* Allocate a Manifest STRING.*/ +T7*s=new7(); +s->_count=c; +s->_capacity=c+1; +s->_storage=((T9)new9(c+1)); +memcpy(s->_storage,e,c+1); +return((T0*)s);}/*--*/ + +T0*se_string(char*e){ +/* Allocate an Eiffel STRING by copying C char*e */ +int c=strlen(e); +T7*s=new7(); +s->_count=c; +s->_capacity=c+1; +s->_storage=((T9)new9(c+1)); +memcpy(s->_storage,e,c+1); +return((T0*)s);}/*--*/ + +void se_msi1(void){ +ms69_1874520032=se_ms(15,s69_1874520032); +ms25_0bc25c15l360=se_ms(0,s25_0); +ms69_22702416=se_ms(9,s69_22702416); +ms69_22702411=se_ms(9,s69_22702411); +ms69_190991=se_ms(6,s69_190991); +ms143_1472358418=se_ms(15,s143_1472358418); +ms69_15980=se_ms(4,s69_15980); +ms25_0bc25=se_ms(0,s25_0); +ms69_188916=se_ms(6,s69_188916); +ms25_0bc69=se_ms(0,s25_0); +ms25_0bc69c15l93=se_ms(0,s25_0); +ms69_1501987274=se_ms(20,s69_1501987274); +ms25_1403610646=se_ms(16,s25_1403610646); +ms25_0=se_ms(0,s25_0); +ms69_10739030=se_ms(8,s69_10739030); +ms69_10739024=se_ms(8,s69_10739024); +ms69_10739017=se_ms(8,s69_10739017); +ms25_1959886733=se_ms(13,s25_1959886733); +ms25_0bc25c15=se_ms(0,s25_0); +ms25_3479972=se_ms(8,s25_3479972); +ms25_21190322=se_ms(9,s25_21190322); +ms69_1756148648=se_ms(13,s69_1756148648); +ms69_1756148653=se_ms(13,s69_1756148653); +ms69_1619665677=se_ms(16,s69_1619665677); +ms69_104371129=se_ms(13,s69_104371129); +ms69_104371267=se_ms(13,s69_104371267); +ms25_314746909=se_ms(16,s25_314746909); +ms25_1638797568=se_ms(17,s25_1638797568); +ms69_1961093439=se_ms(15,s69_1961093439); +ms69_1699147265=se_ms(23,s69_1699147265); +ms69_23436791=se_ms(9,s69_23436791); +ms25_4487261bc69=se_ms(8,s25_4487261); +ms25_694149733=se_ms(18,s25_694149733); +ms69_4738061=se_ms(8,s69_4738061); +ms69_2112369621=se_ms(15,s69_2112369621); +ms25_557679246=se_ms(11,s25_557679246); +ms69_1940108584=se_ms(13,s69_1940108584); +ms69_952626=se_ms(7,s69_952626); +ms69_1461=se_ms(3,s69_1461); +ms69_1466=se_ms(3,s69_1466); +ms69_4725666=se_ms(8,s69_4725666); +ms69_4725661=se_ms(8,s69_4725661); +ms69_56246305=se_ms(9,s69_56246305); +ms69_2676=se_ms(3,s69_2676); +ms25_4487261=se_ms(8,s25_4487261); +ms69_1257860908=se_ms(11,s69_1257860908); +ms69_56246305bc69=se_ms(9,s69_56246305); +ms25_1403610646bc25=se_ms(16,s25_1403610646); +ms69_2057747851=se_ms(20,s69_2057747851); +ms25_0bc69c16=se_ms(0,s25_0); +se_msi2();}/*--*/ + +void se_msi2(void){ +ms25_0bc69c15=se_ms(0,s25_0); +ms69_586741066=se_ms(11,s69_586741066); +ms25_946366=se_ms(7,s25_946366); +ms69_475=se_ms(2,s69_475); +ms69_697=se_ms(2,s69_697); +}/*--*/ + +void W70callback_runner(void* C,void* a1,T2 a2,T212 a3){ +#ifndef FIXED_STACK_BOTTOM +int valid_stack_bottom = stack_bottom != NULL; +#endif +#ifndef FIXED_STACK_BOTTOM +if(!valid_stack_bottom) stack_bottom = (void**)(void*)&valid_stack_bottom; +#endif +r70callback_runner(a1,a2,a3); +#ifndef FIXED_STACK_BOTTOM +if(!valid_stack_bottom) if(!valid_stack_bottom) stack_bottom = NULL; +#endif +}/*--*/ + +void manifest_string_mark1(void){ +gc_mark7((T7*)ms69_1874520032); +gc_mark7((T7*)ms25_0bc25c15l360); +gc_mark7((T7*)ms69_22702416); +gc_mark7((T7*)ms69_22702411); +gc_mark7((T7*)ms69_190991); +gc_mark7((T7*)ms143_1472358418); +gc_mark7((T7*)ms69_15980); +gc_mark7((T7*)ms25_0bc25); +gc_mark7((T7*)ms69_188916); +gc_mark7((T7*)ms25_0bc69); +gc_mark7((T7*)ms25_0bc69c15l93); +gc_mark7((T7*)ms69_1501987274); +gc_mark7((T7*)ms25_1403610646); +gc_mark7((T7*)ms25_0); +gc_mark7((T7*)ms69_10739030); +gc_mark7((T7*)ms69_10739024); +gc_mark7((T7*)ms69_10739017); +gc_mark7((T7*)ms25_1959886733); +gc_mark7((T7*)ms25_0bc25c15); +gc_mark7((T7*)ms25_3479972); +gc_mark7((T7*)ms25_21190322); +gc_mark7((T7*)ms69_1756148648); +gc_mark7((T7*)ms69_1756148653); +gc_mark7((T7*)ms69_1619665677); +gc_mark7((T7*)ms69_104371129); +gc_mark7((T7*)ms69_104371267); +gc_mark7((T7*)ms25_314746909); +gc_mark7((T7*)ms25_1638797568); +gc_mark7((T7*)ms69_1961093439); +gc_mark7((T7*)ms69_1699147265); +gc_mark7((T7*)ms69_23436791); +gc_mark7((T7*)ms25_4487261bc69); +gc_mark7((T7*)ms25_694149733); +gc_mark7((T7*)ms69_4738061); +gc_mark7((T7*)ms69_2112369621); +gc_mark7((T7*)ms25_557679246); +gc_mark7((T7*)ms69_1940108584); +gc_mark7((T7*)ms69_952626); +gc_mark7((T7*)ms69_1461); +gc_mark7((T7*)ms69_1466); +gc_mark7((T7*)ms69_4725666); +gc_mark7((T7*)ms69_4725661); +gc_mark7((T7*)ms69_56246305); +gc_mark7((T7*)ms69_2676); +gc_mark7((T7*)ms25_4487261); +gc_mark7((T7*)ms69_1257860908); +gc_mark7((T7*)ms69_56246305bc69); +gc_mark7((T7*)ms25_1403610646bc25); +gc_mark7((T7*)ms69_2057747851); +gc_mark7((T7*)ms25_0bc69c16); +gc_mark7((T7*)ms25_0bc69c15); +gc_mark7((T7*)ms69_586741066); +gc_mark7((T7*)ms25_946366); +gc_mark7((T7*)ms69_475); +gc_mark7((T7*)ms69_697); +}/*--*/ + +void once_function_mark(void){ +/*NON_VOID_NO_DISPATCH:*/ +gc_mark9((oBC101sprintf_buffer)); +gc_mark43((T43*)(oBC13std_error)); +gc_mark46((T46*)(oBC13io)); +/*Ordinary once functions:*/ +if(NULL!=oBC30command_arguments)gc_mark204((T204*)(oBC30command_arguments)); +if(NULL!=oBC26vision)gc_mark64((T64*)(oBC26vision)); +if(NULL!=oBC13std_output)gc_mark53((T53*)(oBC13std_output)); +if(NULL!=oBC64root_window)gc_mark72((T72*)(oBC64root_window)); +if(NULL!=oBC143x_input_extension)gc_mark175((T175*)(oBC143x_input_extension)); +if(NULL!=oBC13std_input)gc_mark54((T54*)(oBC13std_input)); +if(NULL!=oBC136common_free_nodes)gc_mark244((T244*)(oBC136common_free_nodes)); +}/*--*/ + +void gc_start(void){ +if(gc_is_off)return; +if(garbage_delayed())return; +handle(SE_HANDLE_ENTER_GC,NULL); +gcmt_tail_addr=(((char*)(gcmt[gcmt_used-1]))+(gcmt[gcmt_used-1])->size); +((gc25*)eiffel_root_object)->header.flag=FSOH_UNMARKED; +gc_free110=(void*)0; +gc_free120=(void*)0; +if(na_env293.store_left>0){ +na_env293.store->header.size=na_env293.store_left; +na_env293.store->header.magic_flag=RSOH_FREE; +na_env293.store_left=0; +} +na_env293.chunk_list=NULL; +na_env293.store_chunk=NULL; +if(na_env292.store_left>0){ +na_env292.store->header.size=na_env292.store_left; +na_env292.store->header.magic_flag=RSOH_FREE; +na_env292.store_left=0; +} +na_env292.chunk_list=NULL; +na_env292.store_chunk=NULL; +if(na_env291.store_left>0){ +na_env291.store->header.size=na_env291.store_left; +na_env291.store->header.magic_flag=RSOH_FREE; +na_env291.store_left=0; +} +na_env291.chunk_list=NULL; +na_env291.store_chunk=NULL; +if(na_env290.store_left>0){ +na_env290.store->header.size=na_env290.store_left; +na_env290.store->header.magic_flag=RSOH_FREE; +na_env290.store_left=0; +} +na_env290.chunk_list=NULL; +na_env290.store_chunk=NULL; +if(na_env289.store_left>0){ +na_env289.store->header.size=na_env289.store_left; +na_env289.store->header.magic_flag=RSOH_FREE; +na_env289.store_left=0; +} +na_env289.chunk_list=NULL; +na_env289.store_chunk=NULL; +if(na_env288.store_left>0){ +na_env288.store->header.size=na_env288.store_left; +na_env288.store->header.magic_flag=RSOH_FREE; +na_env288.store_left=0; +} +na_env288.chunk_list=NULL; +na_env288.store_chunk=NULL; +if(na_env287.store_left>0){ +na_env287.store->header.size=na_env287.store_left; +na_env287.store->header.magic_flag=RSOH_FREE; +na_env287.store_left=0; +} +na_env287.chunk_list=NULL; +na_env287.store_chunk=NULL; +gc_free286=(void*)0; +if(na_env284.store_left>0){ +na_env284.store->header.size=na_env284.store_left; +na_env284.store->header.magic_flag=RSOH_FREE; +na_env284.store_left=0; +} +na_env284.chunk_list=NULL; +na_env284.store_chunk=NULL; +if(na_env281.store_left>0){ +na_env281.store->header.size=na_env281.store_left; +na_env281.store->header.magic_flag=RSOH_FREE; +na_env281.store_left=0; +} +na_env281.chunk_list=NULL; +na_env281.store_chunk=NULL; +gc_free277=(void*)0; +if(na_env276.store_left>0){ +na_env276.store->header.size=na_env276.store_left; +na_env276.store->header.magic_flag=RSOH_FREE; +na_env276.store_left=0; +} +na_env276.chunk_list=NULL; +na_env276.store_chunk=NULL; +gc_free271=(void*)0; +if(na_env270.store_left>0){ +na_env270.store->header.size=na_env270.store_left; +na_env270.store->header.magic_flag=RSOH_FREE; +na_env270.store_left=0; +} +na_env270.chunk_list=NULL; +na_env270.store_chunk=NULL; +gc_free268=(void*)0; +if(na_env267.store_left>0){ +na_env267.store->header.size=na_env267.store_left; +na_env267.store->header.magic_flag=RSOH_FREE; +na_env267.store_left=0; +} +na_env267.chunk_list=NULL; +na_env267.store_chunk=NULL; +gc_free266=(void*)0; +gc_free265=(void*)0; +gc_free264=(void*)0; +if(na_env263.store_left>0){ +na_env263.store->header.size=na_env263.store_left; +na_env263.store->header.magic_flag=RSOH_FREE; +na_env263.store_left=0; +} +na_env263.chunk_list=NULL; +na_env263.store_chunk=NULL; +if(na_env262.store_left>0){ +na_env262.store->header.size=na_env262.store_left; +na_env262.store->header.magic_flag=RSOH_FREE; +na_env262.store_left=0; +} +na_env262.chunk_list=NULL; +na_env262.store_chunk=NULL; +if(na_env261.store_left>0){ +na_env261.store->header.size=na_env261.store_left; +na_env261.store->header.magic_flag=RSOH_FREE; +na_env261.store_left=0; +} +na_env261.chunk_list=NULL; +na_env261.store_chunk=NULL; +if(na_env260.store_left>0){ +na_env260.store->header.size=na_env260.store_left; +na_env260.store->header.magic_flag=RSOH_FREE; +na_env260.store_left=0; +} +na_env260.chunk_list=NULL; +na_env260.store_chunk=NULL; +if(na_env259.store_left>0){ +na_env259.store->header.size=na_env259.store_left; +na_env259.store->header.magic_flag=RSOH_FREE; +na_env259.store_left=0; +} +na_env259.chunk_list=NULL; +na_env259.store_chunk=NULL; +gc_free258=(void*)0; +if(na_env257.store_left>0){ +na_env257.store->header.size=na_env257.store_left; +na_env257.store->header.magic_flag=RSOH_FREE; +na_env257.store_left=0; +} +na_env257.chunk_list=NULL; +na_env257.store_chunk=NULL; +gc_free256=(void*)0; +if(na_env255.store_left>0){ +na_env255.store->header.size=na_env255.store_left; +na_env255.store->header.magic_flag=RSOH_FREE; +na_env255.store_left=0; +} +na_env255.chunk_list=NULL; +na_env255.store_chunk=NULL; +gc_free254=(void*)0; +gc_free253=(void*)0; +gc_free252=(void*)0; +if(na_env251.store_left>0){ +na_env251.store->header.size=na_env251.store_left; +na_env251.store->header.magic_flag=RSOH_FREE; +na_env251.store_left=0; +} +na_env251.chunk_list=NULL; +na_env251.store_chunk=NULL; +if(na_env250.store_left>0){ +na_env250.store->header.size=na_env250.store_left; +na_env250.store->header.magic_flag=RSOH_FREE; +na_env250.store_left=0; +} +na_env250.chunk_list=NULL; +na_env250.store_chunk=NULL; +gc_free249=(void*)0; +if(na_env247.store_left>0){ +na_env247.store->header.size=na_env247.store_left; +na_env247.store->header.magic_flag=RSOH_FREE; +na_env247.store_left=0; +} +na_env247.chunk_list=NULL; +na_env247.store_chunk=NULL; +gc_free246=(void*)0; +gc_free245=(void*)0; +gc_free244=(void*)0; +gc_free243=(void*)0; +if(na_env239.store_left>0){ +na_env239.store->header.size=na_env239.store_left; +na_env239.store->header.magic_flag=RSOH_FREE; +na_env239.store_left=0; +} +na_env239.chunk_list=NULL; +na_env239.store_chunk=NULL; +if(na_env238.store_left>0){ +na_env238.store->header.size=na_env238.store_left; +na_env238.store->header.magic_flag=RSOH_FREE; +na_env238.store_left=0; +} +na_env238.chunk_list=NULL; +na_env238.store_chunk=NULL; +if(na_env237.store_left>0){ +na_env237.store->header.size=na_env237.store_left; +na_env237.store->header.magic_flag=RSOH_FREE; +na_env237.store_left=0; +} +na_env237.chunk_list=NULL; +na_env237.store_chunk=NULL; +gc_free147=(void*)0; +gc_free236=(void*)0; +gc_free235=(void*)0; +gc_free234=(void*)0; +gc_free232=(void*)0; +gc_free230=(void*)0; +gc_free228=(void*)0; +gc_free227=(void*)0; +gc_free226=(void*)0; +gc_free225=(void*)0; +gc_free158=(void*)0; +gc_free54=(void*)0; +gc_free139=(void*)0; +gc_free223=(void*)0; +gc_free142=(void*)0; +gc_free222=(void*)0; +gc_free141=(void*)0; +gc_free221=(void*)0; +if(na_env220.store_left>0){ +na_env220.store->header.size=na_env220.store_left; +na_env220.store->header.magic_flag=RSOH_FREE; +na_env220.store_left=0; +} +na_env220.chunk_list=NULL; +na_env220.store_chunk=NULL; +if(na_env219.store_left>0){ +na_env219.store->header.size=na_env219.store_left; +na_env219.store->header.magic_flag=RSOH_FREE; +na_env219.store_left=0; +} +na_env219.chunk_list=NULL; +na_env219.store_chunk=NULL; +gc_free218=(void*)0; +gc_free217=(void*)0; +gc_free216=(void*)0; +gc_free215=(void*)0; +gc_free214=(void*)0; +gc_free213=(void*)0; +if(na_env212.store_left>0){ +na_env212.store->header.size=na_env212.store_left; +na_env212.store->header.magic_flag=RSOH_FREE; +na_env212.store_left=0; +} +na_env212.chunk_list=NULL; +na_env212.store_chunk=NULL; +gc_free211=(void*)0; +gc_free208=(void*)0; +gc_free146=(void*)0; +gc_free207=(void*)0; +gc_free206=(void*)0; +gc_free148=(void*)0; +gc_free131=(void*)0; +gc_free130=(void*)0; +gc_free128=(void*)0; +gc_free72=(void*)0; +gc_free53=(void*)0; +gc_free46=(void*)0; +gc_free175=(void*)0; +gc_free205=(void*)0; +gc_free204=(void*)0; +gc_free67=(void*)0; +gc_free43=(void*)0; +gc_free69=(void*)0; +if(na_env9.store_left>0){ +na_env9.store->header.size=na_env9.store_left; +na_env9.store->header.magic_flag=RSOH_FREE; +na_env9.store_left=0; +} +na_env9.chunk_list=NULL; +na_env9.store_chunk=NULL; +gc_free7=(void*)0; +gc_free70=(void*)0; +gc_free64=(void*)0; +gc_free25=(void*)0; +gc_mark25(eiffel_root_object); +manifest_string_mark1(); +once_function_mark(); +{int i=SE_MAXID-1; +while(i>=0){ +if(g[i]!=NULL)gc_mark7(g[i]); +i--;} +} +{int i=SE_MAXID-1; +while(i>=0){ +if(t[i]!=NULL)gc_mark7(t[i]); +i--;} +} +mark_stack_and_registers(); +gc_sweep(); +collector_counter++; +handle(SE_HANDLE_EXIT_GC,NULL); +}/*--*/ +gc110*store110=(void*)0; +int store_left110=0; +fsoc*store_chunk110=(void*)0; +gc110*gc_free110=(void*)0; +gc120*store120=(void*)0; +int store_left120=0; +fsoc*store_chunk120=(void*)0; +gc120*gc_free120=(void*)0; +na_env na_env293={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark293}; +na_env na_env292={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark292}; +na_env na_env291={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark291}; +na_env na_env290={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark290}; +na_env na_env289={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark289}; +na_env na_env288={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark288}; +na_env na_env287={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark287}; +gc286*store286=(void*)0; +int store_left286=0; +fsoc*store_chunk286=(void*)0; +gc286*gc_free286=(void*)0; +na_env na_env284={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark284}; +na_env na_env281={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark281}; +gc277*store277=(void*)0; +int store_left277=0; +fsoc*store_chunk277=(void*)0; +gc277*gc_free277=(void*)0; +na_env na_env276={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark276}; +gc271*store271=(void*)0; +int store_left271=0; +fsoc*store_chunk271=(void*)0; +gc271*gc_free271=(void*)0; +na_env na_env270={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark270}; +gc268*store268=(void*)0; +int store_left268=0; +fsoc*store_chunk268=(void*)0; +gc268*gc_free268=(void*)0; +na_env na_env267={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark267}; +gc266*store266=(void*)0; +int store_left266=0; +fsoc*store_chunk266=(void*)0; +gc266*gc_free266=(void*)0; +gc265*store265=(void*)0; +int store_left265=0; +fsoc*store_chunk265=(void*)0; +gc265*gc_free265=(void*)0; +gc264*store264=(void*)0; +int store_left264=0; +fsoc*store_chunk264=(void*)0; +gc264*gc_free264=(void*)0; +na_env na_env263={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark263}; +na_env na_env262={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark262}; +na_env na_env261={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark261}; +na_env na_env260={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark260}; +na_env na_env259={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark259}; +gc258*store258=(void*)0; +int store_left258=0; +fsoc*store_chunk258=(void*)0; +gc258*gc_free258=(void*)0; +na_env na_env257={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark257}; +gc256*store256=(void*)0; +int store_left256=0; +fsoc*store_chunk256=(void*)0; +gc256*gc_free256=(void*)0; +na_env na_env255={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark255}; +gc254*store254=(void*)0; +int store_left254=0; +fsoc*store_chunk254=(void*)0; +gc254*gc_free254=(void*)0; +gc253*store253=(void*)0; +int store_left253=0; +fsoc*store_chunk253=(void*)0; +gc253*gc_free253=(void*)0; +gc252*store252=(void*)0; +int store_left252=0; +fsoc*store_chunk252=(void*)0; +gc252*gc_free252=(void*)0; +na_env na_env251={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark251}; +na_env na_env250={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark250}; +gc249*store249=(void*)0; +int store_left249=0; +fsoc*store_chunk249=(void*)0; +gc249*gc_free249=(void*)0; +na_env na_env247={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark247}; +gc246*store246=(void*)0; +int store_left246=0; +fsoc*store_chunk246=(void*)0; +gc246*gc_free246=(void*)0; +gc245*store245=(void*)0; +int store_left245=0; +fsoc*store_chunk245=(void*)0; +gc245*gc_free245=(void*)0; +gc244*store244=(void*)0; +int store_left244=0; +fsoc*store_chunk244=(void*)0; +gc244*gc_free244=(void*)0; +gc243*store243=(void*)0; +int store_left243=0; +fsoc*store_chunk243=(void*)0; +gc243*gc_free243=(void*)0; +na_env na_env239={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark239}; +na_env na_env238={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark238}; +na_env na_env237={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark237}; +gc147*store147=(void*)0; +int store_left147=0; +fsoc*store_chunk147=(void*)0; +gc147*gc_free147=(void*)0; +gc236*store236=(void*)0; +int store_left236=0; +fsoc*store_chunk236=(void*)0; +gc236*gc_free236=(void*)0; +gc235*store235=(void*)0; +int store_left235=0; +fsoc*store_chunk235=(void*)0; +gc235*gc_free235=(void*)0; +gc234*store234=(void*)0; +int store_left234=0; +fsoc*store_chunk234=(void*)0; +gc234*gc_free234=(void*)0; +gc232*store232=(void*)0; +int store_left232=0; +fsoc*store_chunk232=(void*)0; +gc232*gc_free232=(void*)0; +gc230*store230=(void*)0; +int store_left230=0; +fsoc*store_chunk230=(void*)0; +gc230*gc_free230=(void*)0; +gc228*store228=(void*)0; +int store_left228=0; +fsoc*store_chunk228=(void*)0; +gc228*gc_free228=(void*)0; +gc227*store227=(void*)0; +int store_left227=0; +fsoc*store_chunk227=(void*)0; +gc227*gc_free227=(void*)0; +gc226*store226=(void*)0; +int store_left226=0; +fsoc*store_chunk226=(void*)0; +gc226*gc_free226=(void*)0; +gc225*store225=(void*)0; +int store_left225=0; +fsoc*store_chunk225=(void*)0; +gc225*gc_free225=(void*)0; +gc158*store158=(void*)0; +int store_left158=0; +fsoc*store_chunk158=(void*)0; +gc158*gc_free158=(void*)0; +gc54*store54=(void*)0; +int store_left54=0; +fsoc*store_chunk54=(void*)0; +gc54*gc_free54=(void*)0; +gc139*store139=(void*)0; +int store_left139=0; +fsoc*store_chunk139=(void*)0; +gc139*gc_free139=(void*)0; +gc223*store223=(void*)0; +int store_left223=0; +fsoc*store_chunk223=(void*)0; +gc223*gc_free223=(void*)0; +gc142*store142=(void*)0; +int store_left142=0; +fsoc*store_chunk142=(void*)0; +gc142*gc_free142=(void*)0; +gc222*store222=(void*)0; +int store_left222=0; +fsoc*store_chunk222=(void*)0; +gc222*gc_free222=(void*)0; +gc141*store141=(void*)0; +int store_left141=0; +fsoc*store_chunk141=(void*)0; +gc141*gc_free141=(void*)0; +gc221*store221=(void*)0; +int store_left221=0; +fsoc*store_chunk221=(void*)0; +gc221*gc_free221=(void*)0; +na_env na_env220={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark220}; +na_env na_env219={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark219}; +gc218*store218=(void*)0; +int store_left218=0; +fsoc*store_chunk218=(void*)0; +gc218*gc_free218=(void*)0; +gc217*store217=(void*)0; +int store_left217=0; +fsoc*store_chunk217=(void*)0; +gc217*gc_free217=(void*)0; +gc216*store216=(void*)0; +int store_left216=0; +fsoc*store_chunk216=(void*)0; +gc216*gc_free216=(void*)0; +gc215*store215=(void*)0; +int store_left215=0; +fsoc*store_chunk215=(void*)0; +gc215*gc_free215=(void*)0; +gc214*store214=(void*)0; +int store_left214=0; +fsoc*store_chunk214=(void*)0; +gc214*gc_free214=(void*)0; +gc213*store213=(void*)0; +int store_left213=0; +fsoc*store_chunk213=(void*)0; +gc213*gc_free213=(void*)0; +na_env na_env212={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark212}; +gc211*store211=(void*)0; +int store_left211=0; +fsoc*store_chunk211=(void*)0; +gc211*gc_free211=(void*)0; +gc208*store208=(void*)0; +int store_left208=0; +fsoc*store_chunk208=(void*)0; +gc208*gc_free208=(void*)0; +gc146*store146=(void*)0; +int store_left146=0; +fsoc*store_chunk146=(void*)0; +gc146*gc_free146=(void*)0; +gc207*store207=(void*)0; +int store_left207=0; +fsoc*store_chunk207=(void*)0; +gc207*gc_free207=(void*)0; +gc206*store206=(void*)0; +int store_left206=0; +fsoc*store_chunk206=(void*)0; +gc206*gc_free206=(void*)0; +gc148*store148=(void*)0; +int store_left148=0; +fsoc*store_chunk148=(void*)0; +gc148*gc_free148=(void*)0; +gc131*store131=(void*)0; +int store_left131=0; +fsoc*store_chunk131=(void*)0; +gc131*gc_free131=(void*)0; +gc130*store130=(void*)0; +int store_left130=0; +fsoc*store_chunk130=(void*)0; +gc130*gc_free130=(void*)0; +gc128*store128=(void*)0; +int store_left128=0; +fsoc*store_chunk128=(void*)0; +gc128*gc_free128=(void*)0; +gc72*store72=(void*)0; +int store_left72=0; +fsoc*store_chunk72=(void*)0; +gc72*gc_free72=(void*)0; +gc53*store53=(void*)0; +int store_left53=0; +fsoc*store_chunk53=(void*)0; +gc53*gc_free53=(void*)0; +gc46*store46=(void*)0; +int store_left46=0; +fsoc*store_chunk46=(void*)0; +gc46*gc_free46=(void*)0; +gc175*store175=(void*)0; +int store_left175=0; +fsoc*store_chunk175=(void*)0; +gc175*gc_free175=(void*)0; +gc205*store205=(void*)0; +int store_left205=0; +fsoc*store_chunk205=(void*)0; +gc205*gc_free205=(void*)0; +gc204*store204=(void*)0; +int store_left204=0; +fsoc*store_chunk204=(void*)0; +gc204*gc_free204=(void*)0; +gc67*store67=(void*)0; +int store_left67=0; +fsoc*store_chunk67=(void*)0; +gc67*gc_free67=(void*)0; +gc43*store43=(void*)0; +int store_left43=0; +fsoc*store_chunk43=(void*)0; +gc43*gc_free43=(void*)0; +gc69*store69=(void*)0; +int store_left69=0; +fsoc*store_chunk69=(void*)0; +gc69*gc_free69=(void*)0; +na_env na_env9={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark9}; +gc7*store7=(void*)0; +int store_left7=0; +fsoc*store_chunk7=(void*)0; +gc7*gc_free7=(void*)0; +gc70*store70=(void*)0; +int store_left70=0; +fsoc*store_chunk70=(void*)0; +gc70*gc_free70=(void*)0; +gc64*store64=(void*)0; +int store_left64=0; +fsoc*store_chunk64=(void*)0; +gc64*gc_free64=(void*)0; +gc25*store25=(void*)0; +int store_left25=0; +fsoc*store_chunk25=(void*)0; +gc25*gc_free25=(void*)0; + +void gc_sweep110(fsoc*c){ +gc110*o1,*o2; +o1=((gc110*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free110; +gc_free110=o1; +} +} +} +else{ +int dead=1; +gc110* old_gc_free = gc_free110; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free110; +gc_free110=o1; +} +} +if (dead){ +gc_free110 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark110(T110*o){ +if(((gc110*)o)->header.flag==FSOH_UNMARKED){ +((gc110*)o)->header.flag=FSOH_MARKED; +/*ip*/if(NULL!=o->_stream)gc_mark146((T146*)(o->_stream)); +} +}/*--*/ + +void gc_align_mark110(fsoc*c,gc110*p){ +gc110*b=((gc110*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store110)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T110*o=(&(p->object)); +((gc110*)o)->header.flag=FSOH_MARKED; +/*ip*/if(NULL!=o->_stream)gc_mark146((T146*)(o->_stream)); +} +} +}/*--*/ +fsoc H110={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark110, +(void(*)(mch*))gc_sweep110},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc110))-1)}; + +T110*new110(void){ +gc110*n; +fsoc*c; +if(store_left110>1){ +store_left110--; +n=store110++; +} +else if(gc_free110!=NULL){ +n=gc_free110; +gc_free110=n->header.next; +} +else if(store_left110==1){ +store_left110=0; +store_chunk110->header.state_type=FSO_USED_CHUNK; +n=store110++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free110!=NULL){ +n=gc_free110; +gc_free110=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk110=c; +*store_chunk110=H110; +store110=((gc110*)(&(store_chunk110->first_object))); +store_left110=H110.count_minus_one; +n=store110++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M110; +return((T110*)n); +}/*--*/ + +void gc_sweep120(fsoc*c){ +gc120*o1,*o2; +o1=((gc120*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free120; +gc_free120=o1; +} +} +} +else{ +int dead=1; +gc120* old_gc_free = gc_free120; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free120; +gc_free120=o1; +} +} +if (dead){ +gc_free120 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark120(T120*o){ +if(((gc120*)o)->header.flag==FSOH_UNMARKED){ +((gc120*)o)->header.flag=FSOH_MARKED; +/*ip*/if(NULL!=o->_input_stream)Xgc_mark49((T0*)(o->_input_stream)); +} +}/*--*/ + +void gc_align_mark120(fsoc*c,gc120*p){ +gc120*b=((gc120*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store120)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T120*o=(&(p->object)); +((gc120*)o)->header.flag=FSOH_MARKED; +/*ip*/if(NULL!=o->_input_stream)Xgc_mark49((T0*)(o->_input_stream)); +} +} +}/*--*/ +fsoc H120={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark120, +(void(*)(mch*))gc_sweep120},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc120))-1)}; + +T120*new120(void){ +gc120*n; +fsoc*c; +if(store_left120>1){ +store_left120--; +n=store120++; +} +else if(gc_free120!=NULL){ +n=gc_free120; +gc_free120=n->header.next; +} +else if(store_left120==1){ +store_left120=0; +store_chunk120->header.state_type=FSO_USED_CHUNK; +n=store120++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free120!=NULL){ +n=gc_free120; +gc_free120=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk120=c; +*store_chunk120=H120; +store120=((gc120*)(&(store_chunk120->first_object))); +store_left120=H120.count_minus_one; +n=store120++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M120; +return((T120*)n); +}/*--*/ + +void gc_mark293(T293 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T293 new293(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env293.store_left)){ +rsoh*r=na_env293.store; +na_env293.store_left-=size; +if(na_env293.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env293.store=((rsoh*)(((char*)(na_env293.store))+size)); +} +else { +r->header.size=size+na_env293.store_left; +na_env293.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T293)(r+1)); +} +return((T293)new_na(&na_env293,size)); +}/*--*/ + +void gc_mark292(T292 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T292 new292(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env292.store_left)){ +rsoh*r=na_env292.store; +na_env292.store_left-=size; +if(na_env292.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env292.store=((rsoh*)(((char*)(na_env292.store))+size)); +} +else { +r->header.size=size+na_env292.store_left; +na_env292.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T292)(r+1)); +} +return((T292)new_na(&na_env292,size)); +}/*--*/ + +void gc_mark291(T291 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T291 new291(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env291.store_left)){ +rsoh*r=na_env291.store; +na_env291.store_left-=size; +if(na_env291.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env291.store=((rsoh*)(((char*)(na_env291.store))+size)); +} +else { +r->header.size=size+na_env291.store_left; +na_env291.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T291)(r+1)); +} +return((T291)new_na(&na_env291,size)); +}/*--*/ + +void gc_mark290(T290 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark202((T202*)(e)); +}}}} +}/*--*/ + +T290 new290(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env290.store_left)){ +rsoh*r=na_env290.store; +na_env290.store_left-=size; +if(na_env290.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env290.store=((rsoh*)(((char*)(na_env290.store))+size)); +} +else { +r->header.size=size+na_env290.store_left; +na_env290.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T290)(r+1)); +} +return((T290)new_na(&na_env290,size)); +}/*--*/ + +void gc_mark289(T289 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark246((T246*)(e)); +}}}} +}/*--*/ + +T289 new289(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env289.store_left)){ +rsoh*r=na_env289.store; +na_env289.store_left-=size; +if(na_env289.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env289.store=((rsoh*)(((char*)(na_env289.store))+size)); +} +else { +r->header.size=size+na_env289.store_left; +na_env289.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T289)(r+1)); +} +return((T289)new_na(&na_env289,size)); +}/*--*/ + +void gc_mark288(T288 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)Xgc_mark71((T0*)(e)); +}}}} +}/*--*/ + +T288 new288(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env288.store_left)){ +rsoh*r=na_env288.store; +na_env288.store_left-=size; +if(na_env288.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env288.store=((rsoh*)(((char*)(na_env288.store))+size)); +} +else { +r->header.size=size+na_env288.store_left; +na_env288.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T288)(r+1)); +} +return((T288)new_na(&na_env288,size)); +}/*--*/ + +void gc_mark287(T287 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark128((T128*)(e)); +}}}} +}/*--*/ + +T287 new287(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env287.store_left)){ +rsoh*r=na_env287.store; +na_env287.store_left-=size; +if(na_env287.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env287.store=((rsoh*)(((char*)(na_env287.store))+size)); +} +else { +r->header.size=size+na_env287.store_left; +na_env287.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T287)(r+1)); +} +return((T287)new_na(&na_env287,size)); +}/*--*/ + +void gc_sweep286(fsoc*c){ +gc286*o1,*o2; +o1=((gc286*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +} +else{ +o1->header.next=gc_free286; +gc_free286=o1; +} +} +} +else{ +int dead=1; +gc286* old_gc_free = gc_free286; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +dead=0;} +else{ +o1->header.next=gc_free286; +gc_free286=o1; +} +} +if (dead){ +gc_free286 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item_polymorph(T0** item){ +T0* obj_ptr = *item; +if (obj_ptr != NULL){ +int obj_size=se_strucT[obj_ptr->id]; +int swept=(((void*)obj_ptr)<=((void*)item)); +obj_ptr = (T0*)(((char*)obj_ptr) + obj_size); +if (swept!=(((fso_header*)obj_ptr)->flag==FSOH_UNMARKED)) +/* (already swept) xor marked */ +*item = NULL; +} +}/*--*/ + +void gc_mark286(T286*o){ +((gc286*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark286(fsoc*c,gc286*p){ +gc286*b=((gc286*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store286)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T286*o=(&(p->object)); +((gc286*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H286={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark286, +(void(*)(mch*))gc_sweep286},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc286))-1)}; + +T286*new286(void){ +gc286*n; +fsoc*c; +if(store_left286>1){ +store_left286--; +n=store286++; +} +else if(gc_free286!=NULL){ +n=gc_free286; +gc_free286=n->header.next; +} +else if(store_left286==1){ +store_left286=0; +store_chunk286->header.state_type=FSO_USED_CHUNK; +n=store286++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free286!=NULL){ +n=gc_free286; +gc_free286=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk286=c; +*store_chunk286=H286; +store286=((gc286*)(&(store_chunk286->first_object))); +store_left286=H286.count_minus_one; +n=store286++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M286; +return((T286*)n); +}/*--*/ + +void gc_mark284(T284 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T284 new284(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env284.store_left)){ +rsoh*r=na_env284.store; +na_env284.store_left-=size; +if(na_env284.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env284.store=((rsoh*)(((char*)(na_env284.store))+size)); +} +else { +r->header.size=size+na_env284.store_left; +na_env284.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T284)(r+1)); +} +return((T284)new_na(&na_env284,size)); +}/*--*/ + +void gc_mark281(T281 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark234((T234*)(e)); +}}}} +}/*--*/ + +T281 new281(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env281.store_left)){ +rsoh*r=na_env281.store; +na_env281.store_left-=size; +if(na_env281.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env281.store=((rsoh*)(((char*)(na_env281.store))+size)); +} +else { +r->header.size=size+na_env281.store_left; +na_env281.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T281)(r+1)); +} +return((T281)new_na(&na_env281,size)); +}/*--*/ + +void gc_sweep277(fsoc*c){ +gc277*o1,*o2; +o1=((gc277*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +} +else{ +o1->header.next=gc_free277; +gc_free277=o1; +} +} +} +else{ +int dead=1; +gc277* old_gc_free = gc_free277; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +dead=0;} +else{ +o1->header.next=gc_free277; +gc_free277=o1; +} +} +if (dead){ +gc_free277 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark277(T277*o){ +((gc277*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark277(fsoc*c,gc277*p){ +gc277*b=((gc277*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store277)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T277*o=(&(p->object)); +((gc277*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H277={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark277, +(void(*)(mch*))gc_sweep277},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc277))-1)}; + +T277*new277(void){ +gc277*n; +fsoc*c; +if(store_left277>1){ +store_left277--; +n=store277++; +} +else if(gc_free277!=NULL){ +n=gc_free277; +gc_free277=n->header.next; +} +else if(store_left277==1){ +store_left277=0; +store_chunk277->header.state_type=FSO_USED_CHUNK; +n=store277++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free277!=NULL){ +n=gc_free277; +gc_free277=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk277=c; +*store_chunk277=H277; +store277=((gc277*)(&(store_chunk277->first_object))); +store_left277=H277.count_minus_one; +n=store277++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M277; +return((T277*)n); +}/*--*/ + +void gc_mark276(T276 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T276 new276(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env276.store_left)){ +rsoh*r=na_env276.store; +na_env276.store_left-=size; +if(na_env276.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env276.store=((rsoh*)(((char*)(na_env276.store))+size)); +} +else { +r->header.size=size+na_env276.store_left; +na_env276.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T276)(r+1)); +} +return((T276)new_na(&na_env276,size)); +}/*--*/ + +void gc_sweep271(fsoc*c){ +gc271*o1,*o2; +o1=((gc271*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +} +else{ +o1->header.next=gc_free271; +gc_free271=o1; +} +} +} +else{ +int dead=1; +gc271* old_gc_free = gc_free271; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +dead=0;} +else{ +o1->header.next=gc_free271; +gc_free271=o1; +} +} +if (dead){ +gc_free271 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark271(T271*o){ +((gc271*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark271(fsoc*c,gc271*p){ +gc271*b=((gc271*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store271)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T271*o=(&(p->object)); +((gc271*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H271={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark271, +(void(*)(mch*))gc_sweep271},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc271))-1)}; + +T271*new271(void){ +gc271*n; +fsoc*c; +if(store_left271>1){ +store_left271--; +n=store271++; +} +else if(gc_free271!=NULL){ +n=gc_free271; +gc_free271=n->header.next; +} +else if(store_left271==1){ +store_left271=0; +store_chunk271->header.state_type=FSO_USED_CHUNK; +n=store271++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free271!=NULL){ +n=gc_free271; +gc_free271=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk271=c; +*store_chunk271=H271; +store271=((gc271*)(&(store_chunk271->first_object))); +store_left271=H271.count_minus_one; +n=store271++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M271; +return((T271*)n); +}/*--*/ + +void gc_mark270(T270 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T270 new270(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env270.store_left)){ +rsoh*r=na_env270.store; +na_env270.store_left-=size; +if(na_env270.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env270.store=((rsoh*)(((char*)(na_env270.store))+size)); +} +else { +r->header.size=size+na_env270.store_left; +na_env270.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T270)(r+1)); +} +return((T270)new_na(&na_env270,size)); +}/*--*/ + +void gc_sweep268(fsoc*c){ +gc268*o1,*o2; +o1=((gc268*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item268(&(o1->object)); +} +else{ +o1->header.next=gc_free268; +gc_free268=o1; +} +} +} +else{ +int dead=1; +gc268* old_gc_free = gc_free268; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item268(&(o1->object)); +dead=0;} +else{ +o1->header.next=gc_free268; +gc_free268=o1; +} +} +if (dead){ +gc_free268 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item268(T268* wr){ +gc266* obj_ptr = (gc266*)(wr->_item); +if (obj_ptr != NULL){ +int swept = (((void*)obj_ptr) <= ((void*)wr)); +if (swept != (obj_ptr->header.flag == FSOH_UNMARKED)) +/* (already swept) xor marked */ +wr->_item = NULL; +} +}/*--*/ + +void gc_mark268(T268*o){ +((gc268*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark268(fsoc*c,gc268*p){ +gc268*b=((gc268*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store268)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T268*o=(&(p->object)); +((gc268*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H268={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark268, +(void(*)(mch*))gc_sweep268},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc268))-1)}; + +T268*new268(void){ +gc268*n; +fsoc*c; +if(store_left268>1){ +store_left268--; +n=store268++; +} +else if(gc_free268!=NULL){ +n=gc_free268; +gc_free268=n->header.next; +} +else if(store_left268==1){ +store_left268=0; +store_chunk268->header.state_type=FSO_USED_CHUNK; +n=store268++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free268!=NULL){ +n=gc_free268; +gc_free268=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk268=c; +*store_chunk268=H268; +store268=((gc268*)(&(store_chunk268->first_object))); +store_left268=H268.count_minus_one; +n=store268++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M268; +return((T268*)n); +}/*--*/ + +void gc_mark267(T267 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark266((T266*)(e)); +}}}} +}/*--*/ + +T267 new267(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env267.store_left)){ +rsoh*r=na_env267.store; +na_env267.store_left-=size; +if(na_env267.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env267.store=((rsoh*)(((char*)(na_env267.store))+size)); +} +else { +r->header.size=size+na_env267.store_left; +na_env267.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T267)(r+1)); +} +return((T267)new_na(&na_env267,size)); +}/*--*/ + +void gc_sweep266(fsoc*c){ +gc266*o1,*o2; +o1=((gc266*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free266; +gc_free266=o1; +} +} +} +else{ +int dead=1; +gc266* old_gc_free = gc_free266; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free266; +gc_free266=o1; +} +} +if (dead){ +gc_free266 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark266(T266*o){ +begin: +if(((gc266*)o)->header.flag==FSOH_UNMARKED){ +((gc266*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_item)gc_mark72((T72*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark266(fsoc*c,gc266*p){ +gc266*b=((gc266*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store266)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T266*o=(&(p->object)); +begin: +((gc266*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_item)gc_mark72((T72*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL)&&(((gc266*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H266={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark266, +(void(*)(mch*))gc_sweep266},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc266))-1)}; + +T266*new266(void){ +gc266*n; +fsoc*c; +if(store_left266>1){ +store_left266--; +n=store266++; +} +else if(gc_free266!=NULL){ +n=gc_free266; +gc_free266=n->header.next; +} +else if(store_left266==1){ +store_left266=0; +store_chunk266->header.state_type=FSO_USED_CHUNK; +n=store266++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free266!=NULL){ +n=gc_free266; +gc_free266=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk266=c; +*store_chunk266=H266; +store266=((gc266*)(&(store_chunk266->first_object))); +store_left266=H266.count_minus_one; +n=store266++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M266; +return((T266*)n); +}/*--*/ + +void gc_sweep265(fsoc*c){ +gc265*o1,*o2; +o1=((gc265*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item265(&(o1->object)); +} +else{ +o1->header.next=gc_free265; +gc_free265=o1; +} +} +} +else{ +int dead=1; +gc265* old_gc_free = gc_free265; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item265(&(o1->object)); +dead=0;} +else{ +o1->header.next=gc_free265; +gc_free265=o1; +} +} +if (dead){ +gc_free265 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item265(T265* wr){ +gc264* obj_ptr = (gc264*)(wr->_item); +if (obj_ptr != NULL){ +int swept = (((void*)obj_ptr) <= ((void*)wr)); +if (swept != (obj_ptr->header.flag == FSOH_UNMARKED)) +/* (already swept) xor marked */ +wr->_item = NULL; +} +}/*--*/ + +void gc_mark265(T265*o){ +((gc265*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark265(fsoc*c,gc265*p){ +gc265*b=((gc265*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store265)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T265*o=(&(p->object)); +((gc265*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H265={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark265, +(void(*)(mch*))gc_sweep265},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc265))-1)}; + +T265*new265(void){ +gc265*n; +fsoc*c; +if(store_left265>1){ +store_left265--; +n=store265++; +} +else if(gc_free265!=NULL){ +n=gc_free265; +gc_free265=n->header.next; +} +else if(store_left265==1){ +store_left265=0; +store_chunk265->header.state_type=FSO_USED_CHUNK; +n=store265++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free265!=NULL){ +n=gc_free265; +gc_free265=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk265=c; +*store_chunk265=H265; +store265=((gc265*)(&(store_chunk265->first_object))); +store_left265=H265.count_minus_one; +n=store265++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M265; +return((T265*)n); +}/*--*/ + +void gc_sweep264(fsoc*c){ +gc264*o1,*o2; +o1=((gc264*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free264; +gc_free264=o1; +} +} +} +else{ +int dead=1; +gc264* old_gc_free = gc_free264; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free264; +gc_free264=o1; +} +} +if (dead){ +gc_free264 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark264(T264*o){ +begin: +if(((gc264*)o)->header.flag==FSOH_UNMARKED){ +((gc264*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_item)gc_mark67((T67*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark264(fsoc*c,gc264*p){ +gc264*b=((gc264*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store264)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T264*o=(&(p->object)); +begin: +((gc264*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_item)gc_mark67((T67*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL)&&(((gc264*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H264={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark264, +(void(*)(mch*))gc_sweep264},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc264))-1)}; + +T264*new264(void){ +gc264*n; +fsoc*c; +if(store_left264>1){ +store_left264--; +n=store264++; +} +else if(gc_free264!=NULL){ +n=gc_free264; +gc_free264=n->header.next; +} +else if(store_left264==1){ +store_left264=0; +store_chunk264->header.state_type=FSO_USED_CHUNK; +n=store264++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free264!=NULL){ +n=gc_free264; +gc_free264=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk264=c; +*store_chunk264=H264; +store264=((gc264*)(&(store_chunk264->first_object))); +store_left264=H264.count_minus_one; +n=store264++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M264; +return((T264*)n); +}/*--*/ + +void gc_mark263(T263 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark264((T264*)(e)); +}}}} +}/*--*/ + +T263 new263(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env263.store_left)){ +rsoh*r=na_env263.store; +na_env263.store_left-=size; +if(na_env263.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env263.store=((rsoh*)(((char*)(na_env263.store))+size)); +} +else { +r->header.size=size+na_env263.store_left; +na_env263.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T263)(r+1)); +} +return((T263)new_na(&na_env263,size)); +}/*--*/ + +void gc_mark262(T262 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T262 new262(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env262.store_left)){ +rsoh*r=na_env262.store; +na_env262.store_left-=size; +if(na_env262.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env262.store=((rsoh*)(((char*)(na_env262.store))+size)); +} +else { +r->header.size=size+na_env262.store_left; +na_env262.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T262)(r+1)); +} +return((T262)new_na(&na_env262,size)); +}/*--*/ + +void gc_mark261(T261 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark139((T139*)(e)); +}}}} +}/*--*/ + +T261 new261(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env261.store_left)){ +rsoh*r=na_env261.store; +na_env261.store_left-=size; +if(na_env261.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env261.store=((rsoh*)(((char*)(na_env261.store))+size)); +} +else { +r->header.size=size+na_env261.store_left; +na_env261.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T261)(r+1)); +} +return((T261)new_na(&na_env261,size)); +}/*--*/ + +void gc_mark260(T260 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark142((T142*)(e)); +}}}} +}/*--*/ + +T260 new260(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env260.store_left)){ +rsoh*r=na_env260.store; +na_env260.store_left-=size; +if(na_env260.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env260.store=((rsoh*)(((char*)(na_env260.store))+size)); +} +else { +r->header.size=size+na_env260.store_left; +na_env260.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T260)(r+1)); +} +return((T260)new_na(&na_env260,size)); +}/*--*/ + +void gc_mark259(T259 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark141((T141*)(e)); +}}}} +}/*--*/ + +T259 new259(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env259.store_left)){ +rsoh*r=na_env259.store; +na_env259.store_left-=size; +if(na_env259.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env259.store=((rsoh*)(((char*)(na_env259.store))+size)); +} +else { +r->header.size=size+na_env259.store_left; +na_env259.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T259)(r+1)); +} +return((T259)new_na(&na_env259,size)); +}/*--*/ + +void gc_sweep258(fsoc*c){ +gc258*o1,*o2; +o1=((gc258*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item258(&(o1->object)); +} +else{ +o1->header.next=gc_free258; +gc_free258=o1; +} +} +} +else{ +int dead=1; +gc258* old_gc_free = gc_free258; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item258(&(o1->object)); +dead=0;} +else{ +o1->header.next=gc_free258; +gc_free258=o1; +} +} +if (dead){ +gc_free258 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item258(T258* wr){ +gc256* obj_ptr = (gc256*)(wr->_item); +if (obj_ptr != NULL){ +int swept = (((void*)obj_ptr) <= ((void*)wr)); +if (swept != (obj_ptr->header.flag == FSOH_UNMARKED)) +/* (already swept) xor marked */ +wr->_item = NULL; +} +}/*--*/ + +void gc_mark258(T258*o){ +((gc258*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark258(fsoc*c,gc258*p){ +gc258*b=((gc258*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store258)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T258*o=(&(p->object)); +((gc258*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H258={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark258, +(void(*)(mch*))gc_sweep258},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc258))-1)}; + +T258*new258(void){ +gc258*n; +fsoc*c; +if(store_left258>1){ +store_left258--; +n=store258++; +} +else if(gc_free258!=NULL){ +n=gc_free258; +gc_free258=n->header.next; +} +else if(store_left258==1){ +store_left258=0; +store_chunk258->header.state_type=FSO_USED_CHUNK; +n=store258++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free258!=NULL){ +n=gc_free258; +gc_free258=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk258=c; +*store_chunk258=H258; +store258=((gc258*)(&(store_chunk258->first_object))); +store_left258=H258.count_minus_one; +n=store258++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M258; +return((T258*)n); +}/*--*/ + +void gc_mark257(T257 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark256((T256*)(e)); +}}}} +}/*--*/ + +T257 new257(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env257.store_left)){ +rsoh*r=na_env257.store; +na_env257.store_left-=size; +if(na_env257.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env257.store=((rsoh*)(((char*)(na_env257.store))+size)); +} +else { +r->header.size=size+na_env257.store_left; +na_env257.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T257)(r+1)); +} +return((T257)new_na(&na_env257,size)); +}/*--*/ + +void gc_sweep256(fsoc*c){ +gc256*o1,*o2; +o1=((gc256*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free256; +gc_free256=o1; +} +} +} +else{ +int dead=1; +gc256* old_gc_free = gc_free256; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free256; +gc_free256=o1; +} +} +if (dead){ +gc_free256 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark256(T256*o){ +begin: +if(((gc256*)o)->header.flag==FSOH_UNMARKED){ +((gc256*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_key)gc_mark72((T72*)(o->_key)); +/*3p*/if(NULL!=o->_item)gc_mark217((T217*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark256(fsoc*c,gc256*p){ +gc256*b=((gc256*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store256)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T256*o=(&(p->object)); +begin: +((gc256*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_key)gc_mark72((T72*)(o->_key)); +/*3p*/if(NULL!=o->_item)gc_mark217((T217*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL)&&(((gc256*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H256={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark256, +(void(*)(mch*))gc_sweep256},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc256))-1)}; + +T256*new256(void){ +gc256*n; +fsoc*c; +if(store_left256>1){ +store_left256--; +n=store256++; +} +else if(gc_free256!=NULL){ +n=gc_free256; +gc_free256=n->header.next; +} +else if(store_left256==1){ +store_left256=0; +store_chunk256->header.state_type=FSO_USED_CHUNK; +n=store256++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free256!=NULL){ +n=gc_free256; +gc_free256=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk256=c; +*store_chunk256=H256; +store256=((gc256*)(&(store_chunk256->first_object))); +store_left256=H256.count_minus_one; +n=store256++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M256; +return((T256*)n); +}/*--*/ + +void gc_mark255(T255 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark216((T216*)(e)); +}}}} +}/*--*/ + +T255 new255(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env255.store_left)){ +rsoh*r=na_env255.store; +na_env255.store_left-=size; +if(na_env255.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env255.store=((rsoh*)(((char*)(na_env255.store))+size)); +} +else { +r->header.size=size+na_env255.store_left; +na_env255.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T255)(r+1)); +} +return((T255)new_na(&na_env255,size)); +}/*--*/ + +void gc_sweep254(fsoc*c){ +gc254*o1,*o2; +o1=((gc254*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free254; +gc_free254=o1; +} +} +} +else{ +int dead=1; +gc254* old_gc_free = gc_free254; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free254; +gc_free254=o1; +} +} +if (dead){ +gc_free254 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark254(T254*o){ +if(((gc254*)o)->header.flag==FSOH_UNMARKED){ +((gc254*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T290 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r254mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark254(fsoc*c,gc254*p){ +gc254*b=((gc254*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store254)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T254*o=(&(p->object)); +((gc254*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T290 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r254mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H254={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark254, +(void(*)(mch*))gc_sweep254},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc254))-1)}; + +T254*new254(void){ +gc254*n; +fsoc*c; +if(store_left254>1){ +store_left254--; +n=store254++; +} +else if(gc_free254!=NULL){ +n=gc_free254; +gc_free254=n->header.next; +} +else if(store_left254==1){ +store_left254=0; +store_chunk254->header.state_type=FSO_USED_CHUNK; +n=store254++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free254!=NULL){ +n=gc_free254; +gc_free254=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk254=c; +*store_chunk254=H254; +store254=((gc254*)(&(store_chunk254->first_object))); +store_left254=H254.count_minus_one; +n=store254++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M254; +return((T254*)n); +}/*--*/ + +void gc_sweep253(fsoc*c){ +gc253*o1,*o2; +o1=((gc253*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item253(&(o1->object)); +} +else{ +o1->header.next=gc_free253; +gc_free253=o1; +} +} +} +else{ +int dead=1; +gc253* old_gc_free = gc_free253; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item253(&(o1->object)); +dead=0;} +else{ +o1->header.next=gc_free253; +gc_free253=o1; +} +} +if (dead){ +gc_free253 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item253(T253* wr){ +gc252* obj_ptr = (gc252*)(wr->_item); +if (obj_ptr != NULL){ +int swept = (((void*)obj_ptr) <= ((void*)wr)); +if (swept != (obj_ptr->header.flag == FSOH_UNMARKED)) +/* (already swept) xor marked */ +wr->_item = NULL; +} +}/*--*/ + +void gc_mark253(T253*o){ +((gc253*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark253(fsoc*c,gc253*p){ +gc253*b=((gc253*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store253)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T253*o=(&(p->object)); +((gc253*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H253={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark253, +(void(*)(mch*))gc_sweep253},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc253))-1)}; + +T253*new253(void){ +gc253*n; +fsoc*c; +if(store_left253>1){ +store_left253--; +n=store253++; +} +else if(gc_free253!=NULL){ +n=gc_free253; +gc_free253=n->header.next; +} +else if(store_left253==1){ +store_left253=0; +store_chunk253->header.state_type=FSO_USED_CHUNK; +n=store253++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free253!=NULL){ +n=gc_free253; +gc_free253=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk253=c; +*store_chunk253=H253; +store253=((gc253*)(&(store_chunk253->first_object))); +store_left253=H253.count_minus_one; +n=store253++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M253; +return((T253*)n); +}/*--*/ + +void gc_sweep252(fsoc*c){ +gc252*o1,*o2; +o1=((gc252*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free252; +gc_free252=o1; +} +} +} +else{ +int dead=1; +gc252* old_gc_free = gc_free252; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free252; +gc_free252=o1; +} +} +if (dead){ +gc_free252 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark252(T252*o){ +begin: +if(((gc252*)o)->header.flag==FSOH_UNMARKED){ +((gc252*)o)->header.flag=FSOH_MARKED; +o=(void*)o->_next; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark252(fsoc*c,gc252*p){ +gc252*b=((gc252*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store252)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T252*o=(&(p->object)); +begin: +((gc252*)o)->header.flag=FSOH_MARKED; +o=(void*)o->_next; +if((o!=NULL)&&(((gc252*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H252={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark252, +(void(*)(mch*))gc_sweep252},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc252))-1)}; + +T252*new252(void){ +gc252*n; +fsoc*c; +if(store_left252>1){ +store_left252--; +n=store252++; +} +else if(gc_free252!=NULL){ +n=gc_free252; +gc_free252=n->header.next; +} +else if(store_left252==1){ +store_left252=0; +store_chunk252->header.state_type=FSO_USED_CHUNK; +n=store252++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free252!=NULL){ +n=gc_free252; +gc_free252=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk252=c; +*store_chunk252=H252; +store252=((gc252*)(&(store_chunk252->first_object))); +store_left252=H252.count_minus_one; +n=store252++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M252; +return((T252*)n); +}/*--*/ + +void gc_mark251(T251 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark252((T252*)(e)); +}}}} +}/*--*/ + +T251 new251(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env251.store_left)){ +rsoh*r=na_env251.store; +na_env251.store_left-=size; +if(na_env251.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env251.store=((rsoh*)(((char*)(na_env251.store))+size)); +} +else { +r->header.size=size+na_env251.store_left; +na_env251.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T251)(r+1)); +} +return((T251)new_na(&na_env251,size)); +}/*--*/ + +void gc_mark250(T250 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +(((rsoh*)o)-1)->header.magic_flag=RSOH_MARKED; +}/*--*/ + +T250 new250(unsigned int size){ +size=(size*sizeof(T2))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env250.store_left)){ +rsoh*r=na_env250.store; +na_env250.store_left-=size; +if(na_env250.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env250.store=((rsoh*)(((char*)(na_env250.store))+size)); +} +else { +r->header.size=size+na_env250.store_left; +na_env250.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T250)(r+1)); +} +return((T250)new_na(&na_env250,size)); +}/*--*/ + +void gc_sweep249(fsoc*c){ +gc249*o1,*o2; +o1=((gc249*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +} +else{ +o1->header.next=gc_free249; +gc_free249=o1; +} +} +} +else{ +int dead=1; +gc249* old_gc_free = gc_free249; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +dead=0;} +else{ +o1->header.next=gc_free249; +gc_free249=o1; +} +} +if (dead){ +gc_free249 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark249(T249*o){ +((gc249*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark249(fsoc*c,gc249*p){ +gc249*b=((gc249*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store249)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T249*o=(&(p->object)); +((gc249*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H249={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark249, +(void(*)(mch*))gc_sweep249},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc249))-1)}; + +T249*new249(void){ +gc249*n; +fsoc*c; +if(store_left249>1){ +store_left249--; +n=store249++; +} +else if(gc_free249!=NULL){ +n=gc_free249; +gc_free249=n->header.next; +} +else if(store_left249==1){ +store_left249=0; +store_chunk249->header.state_type=FSO_USED_CHUNK; +n=store249++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free249!=NULL){ +n=gc_free249; +gc_free249=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk249=c; +*store_chunk249=H249; +store249=((gc249*)(&(store_chunk249->first_object))); +store_left249=H249.count_minus_one; +n=store249++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M249; +return((T249*)n); +}/*--*/ + +void gc_mark247(T247 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T247 new247(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env247.store_left)){ +rsoh*r=na_env247.store; +na_env247.store_left-=size; +if(na_env247.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env247.store=((rsoh*)(((char*)(na_env247.store))+size)); +} +else { +r->header.size=size+na_env247.store_left; +na_env247.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T247)(r+1)); +} +return((T247)new_na(&na_env247,size)); +}/*--*/ + +void gc_sweep246(fsoc*c){ +gc246*o1,*o2; +o1=((gc246*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free246; +gc_free246=o1; +} +} +} +else{ +int dead=1; +gc246* old_gc_free = gc_free246; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free246; +gc_free246=o1; +} +} +if (dead){ +gc_free246 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark246(T246*o){ +begin: +if(((gc246*)o)->header.flag==FSOH_UNMARKED){ +((gc246*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_key)gc_mark7((T7*)(o->_key)); +/*3p*/if(NULL!=o->_item)Xgc_mark242((T0*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark246(fsoc*c,gc246*p){ +gc246*b=((gc246*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store246)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T246*o=(&(p->object)); +begin: +((gc246*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_key)gc_mark7((T7*)(o->_key)); +/*3p*/if(NULL!=o->_item)Xgc_mark242((T0*)(o->_item)); +o=(void*)o->_next; +if((o!=NULL)&&(((gc246*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H246={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark246, +(void(*)(mch*))gc_sweep246},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc246))-1)}; + +T246*new246(void){ +gc246*n; +fsoc*c; +if(store_left246>1){ +store_left246--; +n=store246++; +} +else if(gc_free246!=NULL){ +n=gc_free246; +gc_free246=n->header.next; +} +else if(store_left246==1){ +store_left246=0; +store_chunk246->header.state_type=FSO_USED_CHUNK; +n=store246++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free246!=NULL){ +n=gc_free246; +gc_free246=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk246=c; +*store_chunk246=H246; +store246=((gc246*)(&(store_chunk246->first_object))); +store_left246=H246.count_minus_one; +n=store246++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M246; +return((T246*)n); +}/*--*/ + +void gc_sweep245(fsoc*c){ +gc245*o1,*o2; +o1=((gc245*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item245(&(o1->object)); +} +else{ +o1->header.next=gc_free245; +gc_free245=o1; +} +} +} +else{ +int dead=1; +gc245* old_gc_free = gc_free245; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item245(&(o1->object)); +dead=0;} +else{ +o1->header.next=gc_free245; +gc_free245=o1; +} +} +if (dead){ +gc_free245 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_update_weak_ref_item245(T245* wr){ +gc246* obj_ptr = (gc246*)(wr->_item); +if (obj_ptr != NULL){ +int swept = (((void*)obj_ptr) <= ((void*)wr)); +if (swept != (obj_ptr->header.flag == FSOH_UNMARKED)) +/* (already swept) xor marked */ +wr->_item = NULL; +} +}/*--*/ + +void gc_mark245(T245*o){ +((gc245*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark245(fsoc*c,gc245*p){ +gc245*b=((gc245*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store245)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T245*o=(&(p->object)); +((gc245*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H245={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark245, +(void(*)(mch*))gc_sweep245},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc245))-1)}; + +T245*new245(void){ +gc245*n; +fsoc*c; +if(store_left245>1){ +store_left245--; +n=store245++; +} +else if(gc_free245!=NULL){ +n=gc_free245; +gc_free245=n->header.next; +} +else if(store_left245==1){ +store_left245=0; +store_chunk245->header.state_type=FSO_USED_CHUNK; +n=store245++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free245!=NULL){ +n=gc_free245; +gc_free245=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk245=c; +*store_chunk245=H245; +store245=((gc245*)(&(store_chunk245->first_object))); +store_left245=H245.count_minus_one; +n=store245++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M245; +return((T245*)n); +}/*--*/ + +void gc_sweep244(fsoc*c){ +gc244*o1,*o2; +o1=((gc244*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free244; +gc_free244=o1; +} +} +} +else{ +int dead=1; +gc244* old_gc_free = gc_free244; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free244; +gc_free244=o1; +} +} +if (dead){ +gc_free244 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark244(T244*o){ +if(((gc244*)o)->header.flag==FSOH_UNMARKED){ +((gc244*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark245((T245*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark289((o->_buckets)); +} +}/*--*/ + +void gc_align_mark244(fsoc*c,gc244*p){ +gc244*b=((gc244*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store244)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T244*o=(&(p->object)); +((gc244*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark245((T245*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark289((o->_buckets)); +} +} +}/*--*/ +fsoc H244={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark244, +(void(*)(mch*))gc_sweep244},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc244))-1)}; + +T244*new244(void){ +gc244*n; +fsoc*c; +if(store_left244>1){ +store_left244--; +n=store244++; +} +else if(gc_free244!=NULL){ +n=gc_free244; +gc_free244=n->header.next; +} +else if(store_left244==1){ +store_left244=0; +store_chunk244->header.state_type=FSO_USED_CHUNK; +n=store244++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free244!=NULL){ +n=gc_free244; +gc_free244=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk244=c; +*store_chunk244=H244; +store244=((gc244*)(&(store_chunk244->first_object))); +store_left244=H244.count_minus_one; +n=store244++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M244; +return((T244*)n); +}/*--*/ + +void gc_sweep243(fsoc*c){ +gc243*o1,*o2; +o1=((gc243*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +} +else{ +o1->header.next=gc_free243; +gc_free243=o1; +} +} +} +else{ +int dead=1; +gc243* old_gc_free = gc_free243; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +gc_update_weak_ref_item_polymorph(&(o1->object._item)); +dead=0;} +else{ +o1->header.next=gc_free243; +gc_free243=o1; +} +} +if (dead){ +gc_free243 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark243(T243*o){ +((gc243*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark243(fsoc*c,gc243*p){ +gc243*b=((gc243*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store243)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T243*o=(&(p->object)); +((gc243*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H243={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark243, +(void(*)(mch*))gc_sweep243},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc243))-1)}; + +T243*new243(void){ +gc243*n; +fsoc*c; +if(store_left243>1){ +store_left243--; +n=store243++; +} +else if(gc_free243!=NULL){ +n=gc_free243; +gc_free243=n->header.next; +} +else if(store_left243==1){ +store_left243=0; +store_chunk243->header.state_type=FSO_USED_CHUNK; +n=store243++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free243!=NULL){ +n=gc_free243; +gc_free243=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk243=c; +*store_chunk243=H243; +store243=((gc243*)(&(store_chunk243->first_object))); +store_left243=H243.count_minus_one; +n=store243++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M243; +return((T243*)n); +}/*--*/ + +void gc_mark239(T239 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +}}}} +}/*--*/ + +T239 new239(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env239.store_left)){ +rsoh*r=na_env239.store; +na_env239.store_left-=size; +if(na_env239.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env239.store=((rsoh*)(((char*)(na_env239.store))+size)); +} +else { +r->header.size=size+na_env239.store_left; +na_env239.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T239)(r+1)); +} +return((T239)new_na(&na_env239,size)); +}/*--*/ + +void gc_mark238(T238 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark146((T146*)(e)); +}}}} +}/*--*/ + +T238 new238(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env238.store_left)){ +rsoh*r=na_env238.store; +na_env238.store_left-=size; +if(na_env238.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env238.store=((rsoh*)(((char*)(na_env238.store))+size)); +} +else { +r->header.size=size+na_env238.store_left; +na_env238.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T238)(r+1)); +} +return((T238)new_na(&na_env238,size)); +}/*--*/ + +void gc_mark237(T237 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark148((T148*)(e)); +}}}} +}/*--*/ + +T237 new237(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env237.store_left)){ +rsoh*r=na_env237.store; +na_env237.store_left-=size; +if(na_env237.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env237.store=((rsoh*)(((char*)(na_env237.store))+size)); +} +else { +r->header.size=size+na_env237.store_left; +na_env237.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T237)(r+1)); +} +return((T237)new_na(&na_env237,size)); +}/*--*/ + +void gc_sweep147(fsoc*c){ +gc147*o1,*o2; +o1=((gc147*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free147; +gc_free147=o1; +} +} +} +else{ +int dead=1; +gc147* old_gc_free = gc_free147; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free147; +gc_free147=o1; +} +} +if (dead){ +gc_free147 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark147(T147*o){ +((gc147*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark147(fsoc*c,gc147*p){ +gc147*b=((gc147*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store147)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T147*o=(&(p->object)); +((gc147*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H147={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark147, +(void(*)(mch*))gc_sweep147},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc147))-1)}; + +T147*new147(void){ +gc147*n; +fsoc*c; +if(store_left147>1){ +store_left147--; +n=store147++; +} +else if(gc_free147!=NULL){ +n=gc_free147; +gc_free147=n->header.next; +} +else if(store_left147==1){ +store_left147=0; +store_chunk147->header.state_type=FSO_USED_CHUNK; +n=store147++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free147!=NULL){ +n=gc_free147; +gc_free147=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk147=c; +*store_chunk147=H147; +store147=((gc147*)(&(store_chunk147->first_object))); +store_left147=H147.count_minus_one; +n=store147++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M147; +return((T147*)n); +}/*--*/ + +void gc_sweep236(fsoc*c){ +gc236*o1,*o2; +o1=((gc236*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free236; +gc_free236=o1; +} +} +} +else{ +int dead=1; +gc236* old_gc_free = gc_free236; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free236; +gc_free236=o1; +} +} +if (dead){ +gc_free236 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark236(T236*o){ +if(((gc236*)o)->header.flag==FSOH_UNMARKED){ +((gc236*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T288 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r236mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark236(fsoc*c,gc236*p){ +gc236*b=((gc236*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store236)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T236*o=(&(p->object)); +((gc236*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T288 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r236mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H236={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark236, +(void(*)(mch*))gc_sweep236},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc236))-1)}; + +T236*new236(void){ +gc236*n; +fsoc*c; +if(store_left236>1){ +store_left236--; +n=store236++; +} +else if(gc_free236!=NULL){ +n=gc_free236; +gc_free236=n->header.next; +} +else if(store_left236==1){ +store_left236=0; +store_chunk236->header.state_type=FSO_USED_CHUNK; +n=store236++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free236!=NULL){ +n=gc_free236; +gc_free236=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk236=c; +*store_chunk236=H236; +store236=((gc236*)(&(store_chunk236->first_object))); +store_left236=H236.count_minus_one; +n=store236++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M236; +return((T236*)n); +}/*--*/ + +void gc_sweep235(fsoc*c){ +gc235*o1,*o2; +o1=((gc235*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free235; +gc_free235=o1; +} +} +} +else{ +int dead=1; +gc235* old_gc_free = gc_free235; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free235; +gc_free235=o1; +} +} +if (dead){ +gc_free235 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark235(T235*o){ +if(((gc235*)o)->header.flag==FSOH_UNMARKED){ +((gc235*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T287 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r235mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark235(fsoc*c,gc235*p){ +gc235*b=((gc235*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store235)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T235*o=(&(p->object)); +((gc235*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T287 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r235mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H235={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark235, +(void(*)(mch*))gc_sweep235},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc235))-1)}; + +T235*new235(void){ +gc235*n; +fsoc*c; +if(store_left235>1){ +store_left235--; +n=store235++; +} +else if(gc_free235!=NULL){ +n=gc_free235; +gc_free235=n->header.next; +} +else if(store_left235==1){ +store_left235=0; +store_chunk235->header.state_type=FSO_USED_CHUNK; +n=store235++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free235!=NULL){ +n=gc_free235; +gc_free235=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk235=c; +*store_chunk235=H235; +store235=((gc235*)(&(store_chunk235->first_object))); +store_left235=H235.count_minus_one; +n=store235++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M235; +return((T235*)n); +}/*--*/ + +void gc_sweep234(fsoc*c){ +gc234*o1,*o2; +o1=((gc234*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free234; +gc_free234=o1; +} +} +} +else{ +int dead=1; +gc234* old_gc_free = gc_free234; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free234; +gc_free234=o1; +} +} +if (dead){ +gc_free234 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark234(T234*o){ +if(((gc234*)o)->header.flag==FSOH_UNMARKED){ +((gc234*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark286((T286*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark284((o->_buckets)); +} +}/*--*/ + +void gc_align_mark234(fsoc*c,gc234*p){ +gc234*b=((gc234*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store234)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T234*o=(&(p->object)); +((gc234*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark286((T286*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark284((o->_buckets)); +} +} +}/*--*/ +fsoc H234={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark234, +(void(*)(mch*))gc_sweep234},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc234))-1)}; + +T234*new234(void){ +gc234*n; +fsoc*c; +if(store_left234>1){ +store_left234--; +n=store234++; +} +else if(gc_free234!=NULL){ +n=gc_free234; +gc_free234=n->header.next; +} +else if(store_left234==1){ +store_left234=0; +store_chunk234->header.state_type=FSO_USED_CHUNK; +n=store234++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free234!=NULL){ +n=gc_free234; +gc_free234=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk234=c; +*store_chunk234=H234; +store234=((gc234*)(&(store_chunk234->first_object))); +store_left234=H234.count_minus_one; +n=store234++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M234; +return((T234*)n); +}/*--*/ + +void gc_sweep232(fsoc*c){ +gc232*o1,*o2; +o1=((gc232*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free232; +gc_free232=o1; +} +} +} +else{ +int dead=1; +gc232* old_gc_free = gc_free232; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free232; +gc_free232=o1; +} +} +if (dead){ +gc_free232 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark232(T232*o){ +if(((gc232*)o)->header.flag==FSOH_UNMARKED){ +((gc232*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T281 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r232mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark232(fsoc*c,gc232*p){ +gc232*b=((gc232*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store232)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T232*o=(&(p->object)); +((gc232*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T281 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r232mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H232={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark232, +(void(*)(mch*))gc_sweep232},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc232))-1)}; + +T232*new232(void){ +gc232*n; +fsoc*c; +if(store_left232>1){ +store_left232--; +n=store232++; +} +else if(gc_free232!=NULL){ +n=gc_free232; +gc_free232=n->header.next; +} +else if(store_left232==1){ +store_left232=0; +store_chunk232->header.state_type=FSO_USED_CHUNK; +n=store232++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free232!=NULL){ +n=gc_free232; +gc_free232=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk232=c; +*store_chunk232=H232; +store232=((gc232*)(&(store_chunk232->first_object))); +store_left232=H232.count_minus_one; +n=store232++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M232; +return((T232*)n); +}/*--*/ + +void gc_sweep230(fsoc*c){ +gc230*o1,*o2; +o1=((gc230*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free230; +gc_free230=o1; +} +} +} +else{ +int dead=1; +gc230* old_gc_free = gc_free230; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free230; +gc_free230=o1; +} +} +if (dead){ +gc_free230 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark230(T230*o){ +if(((gc230*)o)->header.flag==FSOH_UNMARKED){ +((gc230*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark277((T277*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark276((o->_buckets)); +} +}/*--*/ + +void gc_align_mark230(fsoc*c,gc230*p){ +gc230*b=((gc230*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store230)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T230*o=(&(p->object)); +((gc230*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark277((T277*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark276((o->_buckets)); +} +} +}/*--*/ +fsoc H230={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark230, +(void(*)(mch*))gc_sweep230},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc230))-1)}; + +T230*new230(void){ +gc230*n; +fsoc*c; +if(store_left230>1){ +store_left230--; +n=store230++; +} +else if(gc_free230!=NULL){ +n=gc_free230; +gc_free230=n->header.next; +} +else if(store_left230==1){ +store_left230=0; +store_chunk230->header.state_type=FSO_USED_CHUNK; +n=store230++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free230!=NULL){ +n=gc_free230; +gc_free230=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk230=c; +*store_chunk230=H230; +store230=((gc230*)(&(store_chunk230->first_object))); +store_left230=H230.count_minus_one; +n=store230++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M230; +return((T230*)n); +}/*--*/ + +void gc_sweep228(fsoc*c){ +gc228*o1,*o2; +o1=((gc228*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free228; +gc_free228=o1; +} +} +} +else{ +int dead=1; +gc228* old_gc_free = gc_free228; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free228; +gc_free228=o1; +} +} +if (dead){ +gc_free228 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark228(T228*o){ +if(((gc228*)o)->header.flag==FSOH_UNMARKED){ +((gc228*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark271((T271*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark270((o->_buckets)); +} +}/*--*/ + +void gc_align_mark228(fsoc*c,gc228*p){ +gc228*b=((gc228*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store228)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T228*o=(&(p->object)); +((gc228*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark271((T271*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark270((o->_buckets)); +} +} +}/*--*/ +fsoc H228={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark228, +(void(*)(mch*))gc_sweep228},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc228))-1)}; + +T228*new228(void){ +gc228*n; +fsoc*c; +if(store_left228>1){ +store_left228--; +n=store228++; +} +else if(gc_free228!=NULL){ +n=gc_free228; +gc_free228=n->header.next; +} +else if(store_left228==1){ +store_left228=0; +store_chunk228->header.state_type=FSO_USED_CHUNK; +n=store228++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free228!=NULL){ +n=gc_free228; +gc_free228=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk228=c; +*store_chunk228=H228; +store228=((gc228*)(&(store_chunk228->first_object))); +store_left228=H228.count_minus_one; +n=store228++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M228; +return((T228*)n); +}/*--*/ + +void gc_sweep227(fsoc*c){ +gc227*o1,*o2; +o1=((gc227*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free227; +gc_free227=o1; +} +} +} +else{ +int dead=1; +gc227* old_gc_free = gc_free227; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free227; +gc_free227=o1; +} +} +if (dead){ +gc_free227 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark227(T227*o){ +if(((gc227*)o)->header.flag==FSOH_UNMARKED){ +((gc227*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark268((T268*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark267((o->_buckets)); +} +}/*--*/ + +void gc_align_mark227(fsoc*c,gc227*p){ +gc227*b=((gc227*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store227)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T227*o=(&(p->object)); +((gc227*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark268((T268*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark267((o->_buckets)); +} +} +}/*--*/ +fsoc H227={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark227, +(void(*)(mch*))gc_sweep227},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc227))-1)}; + +T227*new227(void){ +gc227*n; +fsoc*c; +if(store_left227>1){ +store_left227--; +n=store227++; +} +else if(gc_free227!=NULL){ +n=gc_free227; +gc_free227=n->header.next; +} +else if(store_left227==1){ +store_left227=0; +store_chunk227->header.state_type=FSO_USED_CHUNK; +n=store227++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free227!=NULL){ +n=gc_free227; +gc_free227=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk227=c; +*store_chunk227=H227; +store227=((gc227*)(&(store_chunk227->first_object))); +store_left227=H227.count_minus_one; +n=store227++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M227; +return((T227*)n); +}/*--*/ + +void gc_sweep226(fsoc*c){ +gc226*o1,*o2; +o1=((gc226*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free226; +gc_free226=o1; +} +} +} +else{ +int dead=1; +gc226* old_gc_free = gc_free226; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free226; +gc_free226=o1; +} +} +if (dead){ +gc_free226 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark226(T226*o){ +if(((gc226*)o)->header.flag==FSOH_UNMARKED){ +((gc226*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark265((T265*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark263((o->_buckets)); +} +}/*--*/ + +void gc_align_mark226(fsoc*c,gc226*p){ +gc226*b=((gc226*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store226)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T226*o=(&(p->object)); +((gc226*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark265((T265*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark263((o->_buckets)); +} +} +}/*--*/ +fsoc H226={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark226, +(void(*)(mch*))gc_sweep226},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc226))-1)}; + +T226*new226(void){ +gc226*n; +fsoc*c; +if(store_left226>1){ +store_left226--; +n=store226++; +} +else if(gc_free226!=NULL){ +n=gc_free226; +gc_free226=n->header.next; +} +else if(store_left226==1){ +store_left226=0; +store_chunk226->header.state_type=FSO_USED_CHUNK; +n=store226++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free226!=NULL){ +n=gc_free226; +gc_free226=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk226=c; +*store_chunk226=H226; +store226=((gc226*)(&(store_chunk226->first_object))); +store_left226=H226.count_minus_one; +n=store226++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M226; +return((T226*)n); +}/*--*/ + +void gc_sweep225(fsoc*c){ +gc225*o1,*o2; +o1=((gc225*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free225; +gc_free225=o1; +} +} +} +else{ +int dead=1; +gc225* old_gc_free = gc_free225; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free225; +gc_free225=o1; +} +} +if (dead){ +gc_free225 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark225(T225*o){ +if(((gc225*)o)->header.flag==FSOH_UNMARKED){ +((gc225*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T262 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r225mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark225(fsoc*c,gc225*p){ +gc225*b=((gc225*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store225)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T225*o=(&(p->object)); +((gc225*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T262 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r225mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H225={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark225, +(void(*)(mch*))gc_sweep225},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc225))-1)}; + +T225*new225(void){ +gc225*n; +fsoc*c; +if(store_left225>1){ +store_left225--; +n=store225++; +} +else if(gc_free225!=NULL){ +n=gc_free225; +gc_free225=n->header.next; +} +else if(store_left225==1){ +store_left225=0; +store_chunk225->header.state_type=FSO_USED_CHUNK; +n=store225++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free225!=NULL){ +n=gc_free225; +gc_free225=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk225=c; +*store_chunk225=H225; +store225=((gc225*)(&(store_chunk225->first_object))); +store_left225=H225.count_minus_one; +n=store225++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M225; +return((T225*)n); +}/*--*/ + +void gc_sweep158(fsoc*c){ +gc158*o1,*o2; +o1=((gc158*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free158; +gc_free158=o1; +} +} +} +else{ +int dead=1; +gc158* old_gc_free = gc_free158; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free158; +gc_free158=o1; +} +} +if (dead){ +gc_free158 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark158(T158*o){ +if(((gc158*)o)->header.flag==FSOH_UNMARKED){ +((gc158*)o)->header.flag=FSOH_MARKED; +/*p*/if(NULL!=o->_container)gc_mark72((T72*)(o->_container)); +} +}/*--*/ + +void gc_align_mark158(fsoc*c,gc158*p){ +gc158*b=((gc158*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store158)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T158*o=(&(p->object)); +((gc158*)o)->header.flag=FSOH_MARKED; +/*p*/if(NULL!=o->_container)gc_mark72((T72*)(o->_container)); +} +} +}/*--*/ +fsoc H158={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark158, +(void(*)(mch*))gc_sweep158},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc158))-1)}; + +T158*new158(void){ +gc158*n; +fsoc*c; +if(store_left158>1){ +store_left158--; +n=store158++; +} +else if(gc_free158!=NULL){ +n=gc_free158; +gc_free158=n->header.next; +} +else if(store_left158==1){ +store_left158=0; +store_chunk158->header.state_type=FSO_USED_CHUNK; +n=store158++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free158!=NULL){ +n=gc_free158; +gc_free158=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk158=c; +*store_chunk158=H158; +store158=((gc158*)(&(store_chunk158->first_object))); +store_left158=H158.count_minus_one; +n=store158++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M158; +return((T158*)n); +}/*--*/ + +void gc_sweep54(fsoc*c){ +gc54*o1,*o2; +o1=((gc54*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r54dispose((T54*)o1); +}o1->header.next=gc_free54; +gc_free54=o1; +} +} +} +else{ +int dead=1; +gc54* old_gc_free = gc_free54; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r54dispose((T54*)o1); +}o1->header.next=gc_free54; +gc_free54=o1; +} +} +if (dead){ +gc_free54 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark54(T54*o){ +if(((gc54*)o)->header.flag==FSOH_UNMARKED){ +((gc54*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_buffer)gc_mark9((o->_buffer)); +} +}/*--*/ + +void gc_align_mark54(fsoc*c,gc54*p){ +gc54*b=((gc54*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store54)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T54*o=(&(p->object)); +((gc54*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_buffer)gc_mark9((o->_buffer)); +} +} +}/*--*/ +fsoc H54={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark54, +(void(*)(mch*))gc_sweep54},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc54))-1)}; + +T54*new54(void){ +gc54*n; +fsoc*c; +if(store_left54>1){ +store_left54--; +n=store54++; +} +else if(gc_free54!=NULL){ +n=gc_free54; +gc_free54=n->header.next; +} +else if(store_left54==1){ +store_left54=0; +store_chunk54->header.state_type=FSO_USED_CHUNK; +n=store54++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free54!=NULL){ +n=gc_free54; +gc_free54=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk54=c; +*store_chunk54=H54; +store54=((gc54*)(&(store_chunk54->first_object))); +store_left54=H54.count_minus_one; +n=store54++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M54; +return((T54*)n); +}/*--*/ + +void gc_sweep139(fsoc*c){ +gc139*o1,*o2; +o1=((gc139*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free139; +gc_free139=o1; +} +} +} +else{ +int dead=1; +gc139* old_gc_free = gc_free139; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free139; +gc_free139=o1; +} +} +if (dead){ +gc_free139 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark139(T139*o){ +((gc139*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark139(fsoc*c,gc139*p){ +gc139*b=((gc139*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store139)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T139*o=(&(p->object)); +((gc139*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H139={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark139, +(void(*)(mch*))gc_sweep139},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc139))-1)}; + +T139*new139(void){ +gc139*n; +fsoc*c; +if(store_left139>1){ +store_left139--; +n=store139++; +} +else if(gc_free139!=NULL){ +n=gc_free139; +gc_free139=n->header.next; +} +else if(store_left139==1){ +store_left139=0; +store_chunk139->header.state_type=FSO_USED_CHUNK; +n=store139++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free139!=NULL){ +n=gc_free139; +gc_free139=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk139=c; +*store_chunk139=H139; +store139=((gc139*)(&(store_chunk139->first_object))); +store_left139=H139.count_minus_one; +n=store139++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M139; +return((T139*)n); +}/*--*/ + +void gc_sweep223(fsoc*c){ +gc223*o1,*o2; +o1=((gc223*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free223; +gc_free223=o1; +} +} +} +else{ +int dead=1; +gc223* old_gc_free = gc_free223; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free223; +gc_free223=o1; +} +} +if (dead){ +gc_free223 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark223(T223*o){ +if(((gc223*)o)->header.flag==FSOH_UNMARKED){ +((gc223*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T261 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r223mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark223(fsoc*c,gc223*p){ +gc223*b=((gc223*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store223)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T223*o=(&(p->object)); +((gc223*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T261 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r223mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H223={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark223, +(void(*)(mch*))gc_sweep223},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc223))-1)}; + +T223*new223(void){ +gc223*n; +fsoc*c; +if(store_left223>1){ +store_left223--; +n=store223++; +} +else if(gc_free223!=NULL){ +n=gc_free223; +gc_free223=n->header.next; +} +else if(store_left223==1){ +store_left223=0; +store_chunk223->header.state_type=FSO_USED_CHUNK; +n=store223++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free223!=NULL){ +n=gc_free223; +gc_free223=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk223=c; +*store_chunk223=H223; +store223=((gc223*)(&(store_chunk223->first_object))); +store_left223=H223.count_minus_one; +n=store223++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M223; +return((T223*)n); +}/*--*/ + +void gc_sweep142(fsoc*c){ +gc142*o1,*o2; +o1=((gc142*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free142; +gc_free142=o1; +} +} +} +else{ +int dead=1; +gc142* old_gc_free = gc_free142; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free142; +gc_free142=o1; +} +} +if (dead){ +gc_free142 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark142(T142*o){ +((gc142*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark142(fsoc*c,gc142*p){ +gc142*b=((gc142*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store142)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T142*o=(&(p->object)); +((gc142*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H142={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark142, +(void(*)(mch*))gc_sweep142},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc142))-1)}; + +T142*new142(void){ +gc142*n; +fsoc*c; +if(store_left142>1){ +store_left142--; +n=store142++; +} +else if(gc_free142!=NULL){ +n=gc_free142; +gc_free142=n->header.next; +} +else if(store_left142==1){ +store_left142=0; +store_chunk142->header.state_type=FSO_USED_CHUNK; +n=store142++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free142!=NULL){ +n=gc_free142; +gc_free142=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk142=c; +*store_chunk142=H142; +store142=((gc142*)(&(store_chunk142->first_object))); +store_left142=H142.count_minus_one; +n=store142++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M142; +return((T142*)n); +}/*--*/ + +void gc_sweep222(fsoc*c){ +gc222*o1,*o2; +o1=((gc222*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free222; +gc_free222=o1; +} +} +} +else{ +int dead=1; +gc222* old_gc_free = gc_free222; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free222; +gc_free222=o1; +} +} +if (dead){ +gc_free222 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark222(T222*o){ +if(((gc222*)o)->header.flag==FSOH_UNMARKED){ +((gc222*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T260 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r222mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark222(fsoc*c,gc222*p){ +gc222*b=((gc222*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store222)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T222*o=(&(p->object)); +((gc222*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T260 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r222mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H222={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark222, +(void(*)(mch*))gc_sweep222},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc222))-1)}; + +T222*new222(void){ +gc222*n; +fsoc*c; +if(store_left222>1){ +store_left222--; +n=store222++; +} +else if(gc_free222!=NULL){ +n=gc_free222; +gc_free222=n->header.next; +} +else if(store_left222==1){ +store_left222=0; +store_chunk222->header.state_type=FSO_USED_CHUNK; +n=store222++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free222!=NULL){ +n=gc_free222; +gc_free222=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk222=c; +*store_chunk222=H222; +store222=((gc222*)(&(store_chunk222->first_object))); +store_left222=H222.count_minus_one; +n=store222++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M222; +return((T222*)n); +}/*--*/ + +void gc_sweep141(fsoc*c){ +gc141*o1,*o2; +o1=((gc141*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free141; +gc_free141=o1; +} +} +} +else{ +int dead=1; +gc141* old_gc_free = gc_free141; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free141; +gc_free141=o1; +} +} +if (dead){ +gc_free141 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark141(T141*o){ +if(((gc141*)o)->header.flag==FSOH_UNMARKED){ +((gc141*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_resolutions)gc_mark214((T214*)(o->_resolutions)); +/*5p*/if(NULL!=o->_maximums)gc_mark214((T214*)(o->_maximums)); +/*5p*/if(NULL!=o->_minimums)gc_mark214((T214*)(o->_minimums)); +} +}/*--*/ + +void gc_align_mark141(fsoc*c,gc141*p){ +gc141*b=((gc141*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store141)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T141*o=(&(p->object)); +((gc141*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_resolutions)gc_mark214((T214*)(o->_resolutions)); +/*5p*/if(NULL!=o->_maximums)gc_mark214((T214*)(o->_maximums)); +/*5p*/if(NULL!=o->_minimums)gc_mark214((T214*)(o->_minimums)); +} +} +}/*--*/ +fsoc H141={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark141, +(void(*)(mch*))gc_sweep141},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc141))-1)}; + +T141*new141(void){ +gc141*n; +fsoc*c; +if(store_left141>1){ +store_left141--; +n=store141++; +} +else if(gc_free141!=NULL){ +n=gc_free141; +gc_free141=n->header.next; +} +else if(store_left141==1){ +store_left141=0; +store_chunk141->header.state_type=FSO_USED_CHUNK; +n=store141++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free141!=NULL){ +n=gc_free141; +gc_free141=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk141=c; +*store_chunk141=H141; +store141=((gc141*)(&(store_chunk141->first_object))); +store_left141=H141.count_minus_one; +n=store141++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M141; +return((T141*)n); +}/*--*/ + +void gc_sweep221(fsoc*c){ +gc221*o1,*o2; +o1=((gc221*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free221; +gc_free221=o1; +} +} +} +else{ +int dead=1; +gc221* old_gc_free = gc_free221; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free221; +gc_free221=o1; +} +} +if (dead){ +gc_free221 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark221(T221*o){ +if(((gc221*)o)->header.flag==FSOH_UNMARKED){ +((gc221*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T259 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r221mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark221(fsoc*c,gc221*p){ +gc221*b=((gc221*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store221)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T221*o=(&(p->object)); +((gc221*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T259 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r221mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H221={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark221, +(void(*)(mch*))gc_sweep221},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc221))-1)}; + +T221*new221(void){ +gc221*n; +fsoc*c; +if(store_left221>1){ +store_left221--; +n=store221++; +} +else if(gc_free221!=NULL){ +n=gc_free221; +gc_free221=n->header.next; +} +else if(store_left221==1){ +store_left221=0; +store_chunk221->header.state_type=FSO_USED_CHUNK; +n=store221++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free221!=NULL){ +n=gc_free221; +gc_free221=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk221=c; +*store_chunk221=H221; +store221=((gc221*)(&(store_chunk221->first_object))); +store_left221=H221.count_minus_one; +n=store221++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M221; +return((T221*)n); +}/*--*/ + +void gc_mark220(T220 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark67((T67*)(e)); +}}}} +}/*--*/ + +T220 new220(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env220.store_left)){ +rsoh*r=na_env220.store; +na_env220.store_left-=size; +if(na_env220.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env220.store=((rsoh*)(((char*)(na_env220.store))+size)); +} +else { +r->header.size=size+na_env220.store_left; +na_env220.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T220)(r+1)); +} +return((T220)new_na(&na_env220,size)); +}/*--*/ + +void gc_mark219(T219 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +{rsoh*h=((rsoh*)o)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; + {T0* e; +T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1))); +for(;((void*)p)>=((void*)o);p--){ +e=*p; +if(NULL!=e)gc_mark7((T7*)(e)); +}}}} +}/*--*/ + +T219 new219(unsigned int size){ +size=(size*sizeof(T0*))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env219.store_left)){ +rsoh*r=na_env219.store; +na_env219.store_left-=size; +if(na_env219.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env219.store=((rsoh*)(((char*)(na_env219.store))+size)); +} +else { +r->header.size=size+na_env219.store_left; +na_env219.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T219)(r+1)); +} +return((T219)new_na(&na_env219,size)); +}/*--*/ + +void gc_sweep218(fsoc*c){ +gc218*o1,*o2; +o1=((gc218*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free218; +gc_free218=o1; +} +} +} +else{ +int dead=1; +gc218* old_gc_free = gc_free218; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free218; +gc_free218=o1; +} +} +if (dead){ +gc_free218 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark218(T218*o){ +if(((gc218*)o)->header.flag==FSOH_UNMARKED){ +((gc218*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark258((T258*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark257((o->_buckets)); +} +}/*--*/ + +void gc_align_mark218(fsoc*c,gc218*p){ +gc218*b=((gc218*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store218)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T218*o=(&(p->object)); +((gc218*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark258((T258*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark257((o->_buckets)); +} +} +}/*--*/ +fsoc H218={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark218, +(void(*)(mch*))gc_sweep218},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc218))-1)}; + +T218*new218(void){ +gc218*n; +fsoc*c; +if(store_left218>1){ +store_left218--; +n=store218++; +} +else if(gc_free218!=NULL){ +n=gc_free218; +gc_free218=n->header.next; +} +else if(store_left218==1){ +store_left218=0; +store_chunk218->header.state_type=FSO_USED_CHUNK; +n=store218++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free218!=NULL){ +n=gc_free218; +gc_free218=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk218=c; +*store_chunk218=H218; +store218=((gc218*)(&(store_chunk218->first_object))); +store_left218=H218.count_minus_one; +n=store218++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M218; +return((T218*)n); +}/*--*/ + +void gc_sweep217(fsoc*c){ +gc217*o1,*o2; +o1=((gc217*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free217; +gc_free217=o1; +} +} +} +else{ +int dead=1; +gc217* old_gc_free = gc_free217; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free217; +gc_free217=o1; +} +} +if (dead){ +gc_free217 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark217(T217*o){ +if(((gc217*)o)->header.flag==FSOH_UNMARKED){ +((gc217*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T255 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r217mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark217(fsoc*c,gc217*p){ +gc217*b=((gc217*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store217)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T217*o=(&(p->object)); +((gc217*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T255 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r217mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H217={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark217, +(void(*)(mch*))gc_sweep217},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc217))-1)}; + +T217*new217(void){ +gc217*n; +fsoc*c; +if(store_left217>1){ +store_left217--; +n=store217++; +} +else if(gc_free217!=NULL){ +n=gc_free217; +gc_free217=n->header.next; +} +else if(store_left217==1){ +store_left217=0; +store_chunk217->header.state_type=FSO_USED_CHUNK; +n=store217++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free217!=NULL){ +n=gc_free217; +gc_free217=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk217=c; +*store_chunk217=H217; +store217=((gc217*)(&(store_chunk217->first_object))); +store_left217=H217.count_minus_one; +n=store217++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M217; +return((T217*)n); +}/*--*/ + +void gc_sweep216(fsoc*c){ +gc216*o1,*o2; +o1=((gc216*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free216; +gc_free216=o1; +} +} +} +else{ +int dead=1; +gc216* old_gc_free = gc_free216; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free216; +gc_free216=o1; +} +} +if (dead){ +gc_free216 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark216(T216*o){ +if(((gc216*)o)->header.flag==FSOH_UNMARKED){ +((gc216*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_callbacks)gc_mark254((T254*)(o->_callbacks)); +} +}/*--*/ + +void gc_align_mark216(fsoc*c,gc216*p){ +gc216*b=((gc216*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store216)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T216*o=(&(p->object)); +((gc216*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_callbacks)gc_mark254((T254*)(o->_callbacks)); +} +} +}/*--*/ +fsoc H216={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark216, +(void(*)(mch*))gc_sweep216},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc216))-1)}; + +T216*new216(void){ +gc216*n; +fsoc*c; +if(store_left216>1){ +store_left216--; +n=store216++; +} +else if(gc_free216!=NULL){ +n=gc_free216; +gc_free216=n->header.next; +} +else if(store_left216==1){ +store_left216=0; +store_chunk216->header.state_type=FSO_USED_CHUNK; +n=store216++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free216!=NULL){ +n=gc_free216; +gc_free216=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk216=c; +*store_chunk216=H216; +store216=((gc216*)(&(store_chunk216->first_object))); +store_left216=H216.count_minus_one; +n=store216++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M216; +return((T216*)n); +}/*--*/ + +void gc_sweep215(fsoc*c){ +gc215*o1,*o2; +o1=((gc215*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free215; +gc_free215=o1; +} +} +} +else{ +int dead=1; +gc215* old_gc_free = gc_free215; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free215; +gc_free215=o1; +} +} +if (dead){ +gc_free215 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark215(T215*o){ +if(((gc215*)o)->header.flag==FSOH_UNMARKED){ +((gc215*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark253((T253*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark251((o->_buckets)); +} +}/*--*/ + +void gc_align_mark215(fsoc*c,gc215*p){ +gc215*b=((gc215*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store215)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T215*o=(&(p->object)); +((gc215*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark253((T253*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark251((o->_buckets)); +} +} +}/*--*/ +fsoc H215={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark215, +(void(*)(mch*))gc_sweep215},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc215))-1)}; + +T215*new215(void){ +gc215*n; +fsoc*c; +if(store_left215>1){ +store_left215--; +n=store215++; +} +else if(gc_free215!=NULL){ +n=gc_free215; +gc_free215=n->header.next; +} +else if(store_left215==1){ +store_left215=0; +store_chunk215->header.state_type=FSO_USED_CHUNK; +n=store215++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free215!=NULL){ +n=gc_free215; +gc_free215=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk215=c; +*store_chunk215=H215; +store215=((gc215*)(&(store_chunk215->first_object))); +store_left215=H215.count_minus_one; +n=store215++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M215; +return((T215*)n); +}/*--*/ + +void gc_sweep214(fsoc*c){ +gc214*o1,*o2; +o1=((gc214*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free214; +gc_free214=o1; +} +} +} +else{ +int dead=1; +gc214* old_gc_free = gc_free214; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free214; +gc_free214=o1; +} +} +if (dead){ +gc_free214 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark214(T214*o){ +if(((gc214*)o)->header.flag==FSOH_UNMARKED){ +((gc214*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_storage)gc_mark250((o->_storage)); +} +}/*--*/ + +void gc_align_mark214(fsoc*c,gc214*p){ +gc214*b=((gc214*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store214)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T214*o=(&(p->object)); +((gc214*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_storage)gc_mark250((o->_storage)); +} +} +}/*--*/ +fsoc H214={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark214, +(void(*)(mch*))gc_sweep214},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc214))-1)}; + +T214*new214(void){ +gc214*n; +fsoc*c; +if(store_left214>1){ +store_left214--; +n=store214++; +} +else if(gc_free214!=NULL){ +n=gc_free214; +gc_free214=n->header.next; +} +else if(store_left214==1){ +store_left214=0; +store_chunk214->header.state_type=FSO_USED_CHUNK; +n=store214++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free214!=NULL){ +n=gc_free214; +gc_free214=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk214=c; +*store_chunk214=H214; +store214=((gc214*)(&(store_chunk214->first_object))); +store_left214=H214.count_minus_one; +n=store214++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M214; +return((T214*)n); +}/*--*/ + +void gc_sweep213(fsoc*c){ +gc213*o1,*o2; +o1=((gc213*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free213; +gc_free213=o1; +} +} +} +else{ +int dead=1; +gc213* old_gc_free = gc_free213; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free213; +gc_free213=o1; +} +} +if (dead){ +gc_free213 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark213(T213*o){ +if(((gc213*)o)->header.flag==FSOH_UNMARKED){ +((gc213*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_storage)gc_mark250((o->_storage)); +} +}/*--*/ + +void gc_align_mark213(fsoc*c,gc213*p){ +gc213*b=((gc213*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store213)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T213*o=(&(p->object)); +((gc213*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_storage)gc_mark250((o->_storage)); +} +} +}/*--*/ +fsoc H213={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark213, +(void(*)(mch*))gc_sweep213},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc213))-1)}; + +T213*new213(void){ +gc213*n; +fsoc*c; +if(store_left213>1){ +store_left213--; +n=store213++; +} +else if(gc_free213!=NULL){ +n=gc_free213; +gc_free213=n->header.next; +} +else if(store_left213==1){ +store_left213=0; +store_chunk213->header.state_type=FSO_USED_CHUNK; +n=store213++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free213!=NULL){ +n=gc_free213; +gc_free213=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk213=c; +*store_chunk213=H213; +store213=((gc213*)(&(store_chunk213->first_object))); +store_left213=H213.count_minus_one; +n=store213++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M213; +return((T213*)n); +}/*--*/ + +void gc_mark212(T212 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +(((rsoh*)o)-1)->header.magic_flag=RSOH_MARKED; +}/*--*/ + +T212 new212(unsigned int size){ +size=(size*sizeof(T8))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env212.store_left)){ +rsoh*r=na_env212.store; +na_env212.store_left-=size; +if(na_env212.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env212.store=((rsoh*)(((char*)(na_env212.store))+size)); +} +else { +r->header.size=size+na_env212.store_left; +na_env212.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T212)(r+1)); +} +return((T212)new_na(&na_env212,size)); +}/*--*/ + +void gc_sweep211(fsoc*c){ +gc211*o1,*o2; +o1=((gc211*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free211; +gc_free211=o1; +} +} +} +else{ +int dead=1; +gc211* old_gc_free = gc_free211; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free211; +gc_free211=o1; +} +} +if (dead){ +gc_free211 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark211(T211*o){ +if(((gc211*)o)->header.flag==FSOH_UNMARKED){ +((gc211*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark249((T249*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark247((o->_buckets)); +} +}/*--*/ + +void gc_align_mark211(fsoc*c,gc211*p){ +gc211*b=((gc211*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store211)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T211*o=(&(p->object)); +((gc211*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark249((T249*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark247((o->_buckets)); +} +} +}/*--*/ +fsoc H211={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark211, +(void(*)(mch*))gc_sweep211},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc211))-1)}; + +T211*new211(void){ +gc211*n; +fsoc*c; +if(store_left211>1){ +store_left211--; +n=store211++; +} +else if(gc_free211!=NULL){ +n=gc_free211; +gc_free211=n->header.next; +} +else if(store_left211==1){ +store_left211=0; +store_chunk211->header.state_type=FSO_USED_CHUNK; +n=store211++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free211!=NULL){ +n=gc_free211; +gc_free211=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk211=c; +*store_chunk211=H211; +store211=((gc211*)(&(store_chunk211->first_object))); +store_left211=H211.count_minus_one; +n=store211++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M211; +return((T211*)n); +}/*--*/ + +void gc_sweep208(fsoc*c){ +gc208*o1,*o2; +o1=((gc208*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free208; +gc_free208=o1; +} +} +} +else{ +int dead=1; +gc208* old_gc_free = gc_free208; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free208; +gc_free208=o1; +} +} +if (dead){ +gc_free208 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark208(T208*o){ +if(((gc208*)o)->header.flag==FSOH_UNMARKED){ +((gc208*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark243((T243*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark239((o->_buckets)); +} +}/*--*/ + +void gc_align_mark208(fsoc*c,gc208*p){ +gc208*b=((gc208*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store208)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T208*o=(&(p->object)); +((gc208*)o)->header.flag=FSOH_MARKED; +/*5p*/if(NULL!=o->_free_nodes)gc_mark243((T243*)(o->_free_nodes)); +/*5p*/if(NULL!=o->_buckets)gc_mark239((o->_buckets)); +} +} +}/*--*/ +fsoc H208={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark208, +(void(*)(mch*))gc_sweep208},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc208))-1)}; + +T208*new208(void){ +gc208*n; +fsoc*c; +if(store_left208>1){ +store_left208--; +n=store208++; +} +else if(gc_free208!=NULL){ +n=gc_free208; +gc_free208=n->header.next; +} +else if(store_left208==1){ +store_left208=0; +store_chunk208->header.state_type=FSO_USED_CHUNK; +n=store208++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free208!=NULL){ +n=gc_free208; +gc_free208=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk208=c; +*store_chunk208=H208; +store208=((gc208*)(&(store_chunk208->first_object))); +store_left208=H208.count_minus_one; +n=store208++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M208; +return((T208*)n); +}/*--*/ + +void gc_sweep146(fsoc*c){ +gc146*o1,*o2; +o1=((gc146*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r146dispose((T146*)o1); +}o1->header.next=gc_free146; +gc_free146=o1; +} +} +} +else{ +int dead=1; +gc146* old_gc_free = gc_free146; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r146dispose((T146*)o1); +}o1->header.next=gc_free146; +gc_free146=o1; +} +} +if (dead){ +gc_free146 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark146(T146*o){ +if(((gc146*)o)->header.flag==FSOH_UNMARKED){ +((gc146*)o)->header.flag=FSOH_MARKED; +/*i7p*/if(NULL!=o->_can_read)gc_mark120((T120*)(o->_can_read)); +/*i7p*/if(NULL!=o->_stream_exception)gc_mark110((T110*)(o->_stream_exception)); +} +}/*--*/ + +void gc_align_mark146(fsoc*c,gc146*p){ +gc146*b=((gc146*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store146)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T146*o=(&(p->object)); +((gc146*)o)->header.flag=FSOH_MARKED; +/*i7p*/if(NULL!=o->_can_read)gc_mark120((T120*)(o->_can_read)); +/*i7p*/if(NULL!=o->_stream_exception)gc_mark110((T110*)(o->_stream_exception)); +} +} +}/*--*/ +fsoc H146={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark146, +(void(*)(mch*))gc_sweep146},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc146))-1)}; + +T146*new146(void){ +gc146*n; +fsoc*c; +if(store_left146>1){ +store_left146--; +n=store146++; +} +else if(gc_free146!=NULL){ +n=gc_free146; +gc_free146=n->header.next; +} +else if(store_left146==1){ +store_left146=0; +store_chunk146->header.state_type=FSO_USED_CHUNK; +n=store146++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free146!=NULL){ +n=gc_free146; +gc_free146=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk146=c; +*store_chunk146=H146; +store146=((gc146*)(&(store_chunk146->first_object))); +store_left146=H146.count_minus_one; +n=store146++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M146; +return((T146*)n); +}/*--*/ + +void gc_sweep207(fsoc*c){ +gc207*o1,*o2; +o1=((gc207*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free207; +gc_free207=o1; +} +} +} +else{ +int dead=1; +gc207* old_gc_free = gc_free207; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free207; +gc_free207=o1; +} +} +if (dead){ +gc_free207 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark207(T207*o){ +if(((gc207*)o)->header.flag==FSOH_UNMARKED){ +((gc207*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T238 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r207mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark207(fsoc*c,gc207*p){ +gc207*b=((gc207*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store207)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T207*o=(&(p->object)); +((gc207*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T238 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r207mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H207={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark207, +(void(*)(mch*))gc_sweep207},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc207))-1)}; + +T207*new207(void){ +gc207*n; +fsoc*c; +if(store_left207>1){ +store_left207--; +n=store207++; +} +else if(gc_free207!=NULL){ +n=gc_free207; +gc_free207=n->header.next; +} +else if(store_left207==1){ +store_left207=0; +store_chunk207->header.state_type=FSO_USED_CHUNK; +n=store207++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free207!=NULL){ +n=gc_free207; +gc_free207=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk207=c; +*store_chunk207=H207; +store207=((gc207*)(&(store_chunk207->first_object))); +store_left207=H207.count_minus_one; +n=store207++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M207; +return((T207*)n); +}/*--*/ + +void gc_sweep206(fsoc*c){ +gc206*o1,*o2; +o1=((gc206*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free206; +gc_free206=o1; +} +} +} +else{ +int dead=1; +gc206* old_gc_free = gc_free206; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free206; +gc_free206=o1; +} +} +if (dead){ +gc_free206 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark206(T206*o){ +if(((gc206*)o)->header.flag==FSOH_UNMARKED){ +((gc206*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T237 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r206mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark206(fsoc*c,gc206*p){ +gc206*b=((gc206*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store206)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T206*o=(&(p->object)); +((gc206*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T237 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r206mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H206={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark206, +(void(*)(mch*))gc_sweep206},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc206))-1)}; + +T206*new206(void){ +gc206*n; +fsoc*c; +if(store_left206>1){ +store_left206--; +n=store206++; +} +else if(gc_free206!=NULL){ +n=gc_free206; +gc_free206=n->header.next; +} +else if(store_left206==1){ +store_left206=0; +store_chunk206->header.state_type=FSO_USED_CHUNK; +n=store206++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free206!=NULL){ +n=gc_free206; +gc_free206=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk206=c; +*store_chunk206=H206; +store206=((gc206*)(&(store_chunk206->first_object))); +store_left206=H206.count_minus_one; +n=store206++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M206; +return((T206*)n); +}/*--*/ + +void gc_sweep148(fsoc*c){ +gc148*o1,*o2; +o1=((gc148*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free148; +gc_free148=o1; +} +} +} +else{ +int dead=1; +gc148* old_gc_free = gc_free148; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free148; +gc_free148=o1; +} +} +if (dead){ +gc_free148 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark148(T148*o){ +if(((gc148*)o)->header.flag==FSOH_UNMARKED){ +((gc148*)o)->header.flag=FSOH_MARKED; +/*6p*/if(NULL!=o->_events)gc_mark147((T147*)(o->_events)); +/*6p*/if(NULL!=o->_ready_jobs)gc_mark236((T236*)(o->_ready_jobs)); +/*6p*/if(NULL!=o->_finished_jobs)gc_mark236((T236*)(o->_finished_jobs)); +/*6p*/if(NULL!=o->_job_list)gc_mark236((T236*)(o->_job_list)); +} +}/*--*/ + +void gc_align_mark148(fsoc*c,gc148*p){ +gc148*b=((gc148*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store148)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T148*o=(&(p->object)); +((gc148*)o)->header.flag=FSOH_MARKED; +/*6p*/if(NULL!=o->_events)gc_mark147((T147*)(o->_events)); +/*6p*/if(NULL!=o->_ready_jobs)gc_mark236((T236*)(o->_ready_jobs)); +/*6p*/if(NULL!=o->_finished_jobs)gc_mark236((T236*)(o->_finished_jobs)); +/*6p*/if(NULL!=o->_job_list)gc_mark236((T236*)(o->_job_list)); +} +} +}/*--*/ +fsoc H148={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark148, +(void(*)(mch*))gc_sweep148},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc148))-1)}; + +T148*new148(void){ +gc148*n; +fsoc*c; +if(store_left148>1){ +store_left148--; +n=store148++; +} +else if(gc_free148!=NULL){ +n=gc_free148; +gc_free148=n->header.next; +} +else if(store_left148==1){ +store_left148=0; +store_chunk148->header.state_type=FSO_USED_CHUNK; +n=store148++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free148!=NULL){ +n=gc_free148; +gc_free148=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk148=c; +*store_chunk148=H148; +store148=((gc148*)(&(store_chunk148->first_object))); +store_left148=H148.count_minus_one; +n=store148++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M148; +return((T148*)n); +}/*--*/ + +void gc_sweep131(fsoc*c){ +gc131*o1,*o2; +o1=((gc131*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r131dispose((T131*)o1); +}o1->header.next=gc_free131; +gc_free131=o1; +} +} +} +else{ +int dead=1; +gc131* old_gc_free = gc_free131; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r131dispose((T131*)o1); +}o1->header.next=gc_free131; +gc_free131=o1; +} +} +if (dead){ +gc_free131 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark131(T131*o){ +if(((gc131*)o)->header.flag==FSOH_UNMARKED){ +((gc131*)o)->header.flag=FSOH_MARKED; +/*i2p*/if(NULL!=o->_can_read)gc_mark120((T120*)(o->_can_read)); +} +}/*--*/ + +void gc_align_mark131(fsoc*c,gc131*p){ +gc131*b=((gc131*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store131)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T131*o=(&(p->object)); +((gc131*)o)->header.flag=FSOH_MARKED; +/*i2p*/if(NULL!=o->_can_read)gc_mark120((T120*)(o->_can_read)); +} +} +}/*--*/ +fsoc H131={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark131, +(void(*)(mch*))gc_sweep131},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc131))-1)}; + +T131*new131(void){ +gc131*n; +fsoc*c; +if(store_left131>1){ +store_left131--; +n=store131++; +} +else if(gc_free131!=NULL){ +n=gc_free131; +gc_free131=n->header.next; +} +else if(store_left131==1){ +store_left131=0; +store_chunk131->header.state_type=FSO_USED_CHUNK; +n=store131++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free131!=NULL){ +n=gc_free131; +gc_free131=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk131=c; +*store_chunk131=H131; +store131=((gc131*)(&(store_chunk131->first_object))); +store_left131=H131.count_minus_one; +n=store131++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M131; +return((T131*)n); +}/*--*/ + +void gc_sweep130(fsoc*c){ +gc130*o1,*o2; +o1=((gc130*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free130; +gc_free130=o1; +} +} +} +else{ +int dead=1; +gc130* old_gc_free = gc_free130; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free130; +gc_free130=o1; +} +} +if (dead){ +gc_free130 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark130(T130*o){ +if(((gc130*)o)->header.flag==FSOH_UNMARKED){ +((gc130*)o)->header.flag=FSOH_MARKED; +/*4p*/if(NULL!=o->_event_catcher_stack)gc_mark235((T235*)(o->_event_catcher_stack)); +/*4p*/if(NULL!=o->_vision)gc_mark64((T64*)(o->_vision)); +/*4p*/if(NULL!=o->_loop_stack)gc_mark206((T206*)(o->_loop_stack)); +} +}/*--*/ + +void gc_align_mark130(fsoc*c,gc130*p){ +gc130*b=((gc130*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store130)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T130*o=(&(p->object)); +((gc130*)o)->header.flag=FSOH_MARKED; +/*4p*/if(NULL!=o->_event_catcher_stack)gc_mark235((T235*)(o->_event_catcher_stack)); +/*4p*/if(NULL!=o->_vision)gc_mark64((T64*)(o->_vision)); +/*4p*/if(NULL!=o->_loop_stack)gc_mark206((T206*)(o->_loop_stack)); +} +} +}/*--*/ +fsoc H130={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark130, +(void(*)(mch*))gc_sweep130},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc130))-1)}; + +T130*new130(void){ +gc130*n; +fsoc*c; +if(store_left130>1){ +store_left130--; +n=store130++; +} +else if(gc_free130!=NULL){ +n=gc_free130; +gc_free130=n->header.next; +} +else if(store_left130==1){ +store_left130=0; +store_chunk130->header.state_type=FSO_USED_CHUNK; +n=store130++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free130!=NULL){ +n=gc_free130; +gc_free130=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk130=c; +*store_chunk130=H130; +store130=((gc130*)(&(store_chunk130->first_object))); +store_left130=H130.count_minus_one; +n=store130++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M130; +return((T130*)n); +}/*--*/ + +void gc_sweep128(fsoc*c){ +gc128*o1,*o2; +o1=((gc128*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free128; +gc_free128=o1; +} +} +} +else{ +int dead=1; +gc128* old_gc_free = gc_free128; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free128; +gc_free128=o1; +} +} +if (dead){ +gc_free128 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark128(T128*o){ +begin: +if(((gc128*)o)->header.flag==FSOH_UNMARKED){ +((gc128*)o)->header.flag=FSOH_MARKED; +/*i11p*/if(NULL!=o->_graphic_connection)gc_mark131((T131*)(o->_graphic_connection)); +/*i11p*/if(NULL!=o->_extension_devices)gc_mark226((T226*)(o->_extension_devices)); +/*i11p*/if(NULL!=o->_geometry_change_event)gc_mark228((T228*)(o->_geometry_change_event)); +/*i11p*/if(NULL!=o->_pointer_move_event)gc_mark230((T230*)(o->_pointer_move_event)); +/*i11p*/if(NULL!=o->_event)gc_mark232((T232*)(o->_event)); +/*i11p*/if(NULL!=o->_widget)gc_mark227((T227*)(o->_widget)); +o=(void*)o->_event_catcher_found; +if((o!=NULL))goto begin; +} +}/*--*/ + +void gc_align_mark128(fsoc*c,gc128*p){ +gc128*b=((gc128*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store128)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T128*o=(&(p->object)); +begin: +((gc128*)o)->header.flag=FSOH_MARKED; +/*i11p*/if(NULL!=o->_graphic_connection)gc_mark131((T131*)(o->_graphic_connection)); +/*i11p*/if(NULL!=o->_extension_devices)gc_mark226((T226*)(o->_extension_devices)); +/*i11p*/if(NULL!=o->_geometry_change_event)gc_mark228((T228*)(o->_geometry_change_event)); +/*i11p*/if(NULL!=o->_pointer_move_event)gc_mark230((T230*)(o->_pointer_move_event)); +/*i11p*/if(NULL!=o->_event)gc_mark232((T232*)(o->_event)); +/*i11p*/if(NULL!=o->_widget)gc_mark227((T227*)(o->_widget)); +o=(void*)o->_event_catcher_found; +if((o!=NULL)&&(((gc128*)o)->header.flag==FSOH_UNMARKED))goto begin; +} +} +}/*--*/ +fsoc H128={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark128, +(void(*)(mch*))gc_sweep128},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc128))-1)}; + +T128*new128(void){ +gc128*n; +fsoc*c; +if(store_left128>1){ +store_left128--; +n=store128++; +} +else if(gc_free128!=NULL){ +n=gc_free128; +gc_free128=n->header.next; +} +else if(store_left128==1){ +store_left128=0; +store_chunk128->header.state_type=FSO_USED_CHUNK; +n=store128++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free128!=NULL){ +n=gc_free128; +gc_free128=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk128=c; +*store_chunk128=H128; +store128=((gc128*)(&(store_chunk128->first_object))); +store_left128=H128.count_minus_one; +n=store128++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M128; +return((T128*)n); +}/*--*/ + +void gc_sweep72(fsoc*c){ +gc72*o1,*o2; +o1=((gc72*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free72; +gc_free72=o1; +} +} +} +else{ +int dead=1; +gc72* old_gc_free = gc_free72; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free72; +gc_free72=o1; +} +} +if (dead){ +gc_free72 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark72(T72*o){ +if(((gc72*)o)->header.flag==FSOH_UNMARKED){ +((gc72*)o)->header.flag=FSOH_MARKED; +/*11p*/if(NULL!=o->_child)gc_mark225((T225*)(o->_child)); +/*11p*/if(NULL!=o->_layout)gc_mark158((T158*)(o->_layout)); +} +}/*--*/ + +void gc_align_mark72(fsoc*c,gc72*p){ +gc72*b=((gc72*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store72)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T72*o=(&(p->object)); +((gc72*)o)->header.flag=FSOH_MARKED; +/*11p*/if(NULL!=o->_child)gc_mark225((T225*)(o->_child)); +/*11p*/if(NULL!=o->_layout)gc_mark158((T158*)(o->_layout)); +} +} +}/*--*/ +fsoc H72={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark72, +(void(*)(mch*))gc_sweep72},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc72))-1)}; + +T72*new72(void){ +gc72*n; +fsoc*c; +if(store_left72>1){ +store_left72--; +n=store72++; +} +else if(gc_free72!=NULL){ +n=gc_free72; +gc_free72=n->header.next; +} +else if(store_left72==1){ +store_left72=0; +store_chunk72->header.state_type=FSO_USED_CHUNK; +n=store72++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free72!=NULL){ +n=gc_free72; +gc_free72=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk72=c; +*store_chunk72=H72; +store72=((gc72*)(&(store_chunk72->first_object))); +store_left72=H72.count_minus_one; +n=store72++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M72; +return((T72*)n); +}/*--*/ + +void gc_sweep53(fsoc*c){ +gc53*o1,*o2; +o1=((gc53*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r53dispose((T53*)o1); +}o1->header.next=gc_free53; +gc_free53=o1; +} +} +} +else{ +int dead=1; +gc53* old_gc_free = gc_free53; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r53dispose((T53*)o1); +}o1->header.next=gc_free53; +gc_free53=o1; +} +} +if (dead){ +gc_free53 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark53(T53*o){ +if(((gc53*)o)->header.flag==FSOH_UNMARKED){ +((gc53*)o)->header.flag=FSOH_MARKED; +/*4p*/if(NULL!=o->_buffer)gc_mark9((o->_buffer)); +/*4p*/} +}/*--*/ + +void gc_align_mark53(fsoc*c,gc53*p){ +gc53*b=((gc53*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store53)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T53*o=(&(p->object)); +((gc53*)o)->header.flag=FSOH_MARKED; +/*4p*/if(NULL!=o->_buffer)gc_mark9((o->_buffer)); +/*4p*/} +} +}/*--*/ +fsoc H53={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark53, +(void(*)(mch*))gc_sweep53},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc53))-1)}; + +T53*new53(void){ +gc53*n; +fsoc*c; +if(store_left53>1){ +store_left53--; +n=store53++; +} +else if(gc_free53!=NULL){ +n=gc_free53; +gc_free53=n->header.next; +} +else if(store_left53==1){ +store_left53=0; +store_chunk53->header.state_type=FSO_USED_CHUNK; +n=store53++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free53!=NULL){ +n=gc_free53; +gc_free53=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk53=c; +*store_chunk53=H53; +store53=((gc53*)(&(store_chunk53->first_object))); +store_left53=H53.count_minus_one; +n=store53++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M53; +return((T53*)n); +}/*--*/ + +void gc_sweep46(fsoc*c){ +gc46*o1,*o2; +o1=((gc46*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r46dispose(); +}o1->header.next=gc_free46; +gc_free46=o1; +} +} +} +else{ +int dead=1; +gc46* old_gc_free = gc_free46; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r46dispose(); +}o1->header.next=gc_free46; +gc_free46=o1; +} +} +if (dead){ +gc_free46 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark46(T46*o){ +((gc46*)o)->header.flag=FSOH_MARKED; +}/*--*/ + +void gc_align_mark46(fsoc*c,gc46*p){ +gc46*b=((gc46*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store46)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T46*o=(&(p->object)); +((gc46*)o)->header.flag=FSOH_MARKED; +} +} +}/*--*/ +fsoc H46={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark46, +(void(*)(mch*))gc_sweep46},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc46))-1)}; + +T46*new46(void){ +gc46*n; +fsoc*c; +if(store_left46>1){ +store_left46--; +n=store46++; +} +else if(gc_free46!=NULL){ +n=gc_free46; +gc_free46=n->header.next; +} +else if(store_left46==1){ +store_left46=0; +store_chunk46->header.state_type=FSO_USED_CHUNK; +n=store46++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free46!=NULL){ +n=gc_free46; +gc_free46=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk46=c; +*store_chunk46=H46; +store46=((gc46*)(&(store_chunk46->first_object))); +store_left46=H46.count_minus_one; +n=store46++; +} +} +n->header.flag=FSOH_UNMARKED; +return((T46*)n); +}/*--*/ + +void gc_sweep175(fsoc*c){ +gc175*o1,*o2; +o1=((gc175*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free175; +gc_free175=o1; +} +} +} +else{ +int dead=1; +gc175* old_gc_free = gc_free175; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free175; +gc_free175=o1; +} +} +if (dead){ +gc_free175 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark175(T175*o){ +if(((gc175*)o)->header.flag==FSOH_UNMARKED){ +((gc175*)o)->header.flag=FSOH_MARKED; +/*p*/if(NULL!=o->_devices)gc_mark205((T205*)(o->_devices)); +} +}/*--*/ + +void gc_align_mark175(fsoc*c,gc175*p){ +gc175*b=((gc175*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store175)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T175*o=(&(p->object)); +((gc175*)o)->header.flag=FSOH_MARKED; +/*p*/if(NULL!=o->_devices)gc_mark205((T205*)(o->_devices)); +} +} +}/*--*/ +fsoc H175={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark175, +(void(*)(mch*))gc_sweep175},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc175))-1)}; + +T175*new175(void){ +gc175*n; +fsoc*c; +if(store_left175>1){ +store_left175--; +n=store175++; +} +else if(gc_free175!=NULL){ +n=gc_free175; +gc_free175=n->header.next; +} +else if(store_left175==1){ +store_left175=0; +store_chunk175->header.state_type=FSO_USED_CHUNK; +n=store175++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free175!=NULL){ +n=gc_free175; +gc_free175=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk175=c; +*store_chunk175=H175; +store175=((gc175*)(&(store_chunk175->first_object))); +store_left175=H175.count_minus_one; +n=store175++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M175; +return((T175*)n); +}/*--*/ + +void gc_sweep205(fsoc*c){ +gc205*o1,*o2; +o1=((gc205*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free205; +gc_free205=o1; +} +} +} +else{ +int dead=1; +gc205* old_gc_free = gc_free205; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free205; +gc_free205=o1; +} +} +if (dead){ +gc_free205 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark205(T205*o){ +if(((gc205*)o)->header.flag==FSOH_UNMARKED){ +((gc205*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T220 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r205mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark205(fsoc*c,gc205*p){ +gc205*b=((gc205*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store205)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T205*o=(&(p->object)); +((gc205*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T220 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r205mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H205={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark205, +(void(*)(mch*))gc_sweep205},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc205))-1)}; + +T205*new205(void){ +gc205*n; +fsoc*c; +if(store_left205>1){ +store_left205--; +n=store205++; +} +else if(gc_free205!=NULL){ +n=gc_free205; +gc_free205=n->header.next; +} +else if(store_left205==1){ +store_left205=0; +store_chunk205->header.state_type=FSO_USED_CHUNK; +n=store205++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free205!=NULL){ +n=gc_free205; +gc_free205=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk205=c; +*store_chunk205=H205; +store205=((gc205*)(&(store_chunk205->first_object))); +store_left205=H205.count_minus_one; +n=store205++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M205; +return((T205*)n); +}/*--*/ + +void gc_sweep204(fsoc*c){ +gc204*o1,*o2; +o1=((gc204*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free204; +gc_free204=o1; +} +} +} +else{ +int dead=1; +gc204* old_gc_free = gc_free204; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free204; +gc_free204=o1; +} +} +if (dead){ +gc_free204 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark204(T204*o){ +if(((gc204*)o)->header.flag==FSOH_UNMARKED){ +((gc204*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T219 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r204mark_native_arrays(o); +} +} +}} +}/*--*/ + +void gc_align_mark204(fsoc*c,gc204*p){ +gc204*b=((gc204*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store204)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T204*o=(&(p->object)); +((gc204*)o)->header.flag=FSOH_MARKED; +/*3p*/{ +T219 na=o->_storage; +if(gc_find_chunk(na)!=NULL){/* non external NA */ + rsoh*h=((rsoh*)na)-1; + if((h->header.magic_flag)==RSOH_UNMARKED){ + h->header.magic_flag=RSOH_MARKED; +r204mark_native_arrays(o); +} +} +}} +} +}/*--*/ +fsoc H204={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark204, +(void(*)(mch*))gc_sweep204},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc204))-1)}; + +T204*new204(void){ +gc204*n; +fsoc*c; +if(store_left204>1){ +store_left204--; +n=store204++; +} +else if(gc_free204!=NULL){ +n=gc_free204; +gc_free204=n->header.next; +} +else if(store_left204==1){ +store_left204=0; +store_chunk204->header.state_type=FSO_USED_CHUNK; +n=store204++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free204!=NULL){ +n=gc_free204; +gc_free204=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk204=c; +*store_chunk204=H204; +store204=((gc204*)(&(store_chunk204->first_object))); +store_left204=H204.count_minus_one; +n=store204++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M204; +return((T204*)n); +}/*--*/ + +void gc_sweep67(fsoc*c){ +gc67*o1,*o2; +o1=((gc67*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free67; +gc_free67=o1; +} +} +} +else{ +int dead=1; +gc67* old_gc_free = gc_free67; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free67; +gc_free67=o1; +} +} +if (dead){ +gc_free67 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark67(T67*o){ +if(((gc67*)o)->header.flag==FSOH_UNMARKED){ +((gc67*)o)->header.flag=FSOH_MARKED; +/*14p*/if(NULL!=o->_events_id)gc_mark214((T214*)(o->_events_id)); +/*14p*/if(NULL!=o->_events_indexes)gc_mark215((T215*)(o->_events_indexes)); +/*14p*/if(NULL!=o->_actions)gc_mark218((T218*)(o->_actions)); +/*14p*/if(NULL!=o->_axes_capabilities)gc_mark221((T221*)(o->_axes_capabilities)); +/*14p*/if(NULL!=o->_button_capabilities)gc_mark222((T222*)(o->_button_capabilities)); +/*14p*/if(NULL!=o->_key_capabilities)gc_mark223((T223*)(o->_key_capabilities)); +/*14p*/if(NULL!=o->_type)gc_mark7((T7*)(o->_type)); +/*14p*/if(NULL!=o->_name)gc_mark7((T7*)(o->_name)); +} +}/*--*/ + +void gc_align_mark67(fsoc*c,gc67*p){ +gc67*b=((gc67*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store67)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T67*o=(&(p->object)); +((gc67*)o)->header.flag=FSOH_MARKED; +/*14p*/if(NULL!=o->_events_id)gc_mark214((T214*)(o->_events_id)); +/*14p*/if(NULL!=o->_events_indexes)gc_mark215((T215*)(o->_events_indexes)); +/*14p*/if(NULL!=o->_actions)gc_mark218((T218*)(o->_actions)); +/*14p*/if(NULL!=o->_axes_capabilities)gc_mark221((T221*)(o->_axes_capabilities)); +/*14p*/if(NULL!=o->_button_capabilities)gc_mark222((T222*)(o->_button_capabilities)); +/*14p*/if(NULL!=o->_key_capabilities)gc_mark223((T223*)(o->_key_capabilities)); +/*14p*/if(NULL!=o->_type)gc_mark7((T7*)(o->_type)); +/*14p*/if(NULL!=o->_name)gc_mark7((T7*)(o->_name)); +} +} +}/*--*/ +fsoc H67={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark67, +(void(*)(mch*))gc_sweep67},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc67))-1)}; + +T67*new67(void){ +gc67*n; +fsoc*c; +if(store_left67>1){ +store_left67--; +n=store67++; +} +else if(gc_free67!=NULL){ +n=gc_free67; +gc_free67=n->header.next; +} +else if(store_left67==1){ +store_left67=0; +store_chunk67->header.state_type=FSO_USED_CHUNK; +n=store67++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free67!=NULL){ +n=gc_free67; +gc_free67=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk67=c; +*store_chunk67=H67; +store67=((gc67*)(&(store_chunk67->first_object))); +store_left67=H67.count_minus_one; +n=store67++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M67; +return((T67*)n); +}/*--*/ + +void gc_sweep43(fsoc*c){ +gc43*o1,*o2; +o1=((gc43*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r43dispose((T43*)o1); +}o1->header.next=gc_free43; +gc_free43=o1; +} +} +} +else{ +int dead=1; +gc43* old_gc_free = gc_free43; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +if((o1->header.flag)==FSOH_UNMARKED){ +r43dispose((T43*)o1); +}o1->header.next=gc_free43; +gc_free43=o1; +} +} +if (dead){ +gc_free43 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark43(T43*o){ +if(((gc43*)o)->header.flag==FSOH_UNMARKED){ +((gc43*)o)->header.flag=FSOH_MARKED; +/*p*/} +}/*--*/ + +void gc_align_mark43(fsoc*c,gc43*p){ +gc43*b=((gc43*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store43)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T43*o=(&(p->object)); +((gc43*)o)->header.flag=FSOH_MARKED; +/*p*/} +} +}/*--*/ +fsoc H43={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark43, +(void(*)(mch*))gc_sweep43},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc43))-1)}; + +T43*new43(void){ +gc43*n; +fsoc*c; +if(store_left43>1){ +store_left43--; +n=store43++; +} +else if(gc_free43!=NULL){ +n=gc_free43; +gc_free43=n->header.next; +} +else if(store_left43==1){ +store_left43=0; +store_chunk43->header.state_type=FSO_USED_CHUNK; +n=store43++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free43!=NULL){ +n=gc_free43; +gc_free43=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk43=c; +*store_chunk43=H43; +store43=((gc43*)(&(store_chunk43->first_object))); +store_left43=H43.count_minus_one; +n=store43++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M43; +return((T43*)n); +}/*--*/ + +void gc_sweep69(fsoc*c){ +gc69*o1,*o2; +o1=((gc69*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free69; +gc_free69=o1; +} +} +} +else{ +int dead=1; +gc69* old_gc_free = gc_free69; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free69; +gc_free69=o1; +} +} +if (dead){ +gc_free69 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark69(T69*o){ +if(((gc69*)o)->header.flag==FSOH_UNMARKED){ +((gc69*)o)->header.flag=FSOH_MARKED; +/*25p*/if(NULL!=o->_time_history)gc_mark213((T213*)(o->_time_history)); +/*25p*/if(NULL!=o->_x_history)gc_mark213((T213*)(o->_x_history)); +/*25p*/if(NULL!=o->_y_history)gc_mark213((T213*)(o->_y_history)); +/*25p*/if(NULL!=o->_pointer_message_header)gc_mark7((T7*)(o->_pointer_message_header)); +/*25p*/if(NULL!=o->_button_message_header)gc_mark7((T7*)(o->_button_message_header)); +/*25p*/if(NULL!=o->_xinput_ivy)gc_mark25((T25*)(o->_xinput_ivy)); +} +}/*--*/ + +void gc_align_mark69(fsoc*c,gc69*p){ +gc69*b=((gc69*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store69)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T69*o=(&(p->object)); +((gc69*)o)->header.flag=FSOH_MARKED; +/*25p*/if(NULL!=o->_time_history)gc_mark213((T213*)(o->_time_history)); +/*25p*/if(NULL!=o->_x_history)gc_mark213((T213*)(o->_x_history)); +/*25p*/if(NULL!=o->_y_history)gc_mark213((T213*)(o->_y_history)); +/*25p*/if(NULL!=o->_pointer_message_header)gc_mark7((T7*)(o->_pointer_message_header)); +/*25p*/if(NULL!=o->_button_message_header)gc_mark7((T7*)(o->_button_message_header)); +/*25p*/if(NULL!=o->_xinput_ivy)gc_mark25((T25*)(o->_xinput_ivy)); +} +} +}/*--*/ +fsoc H69={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark69, +(void(*)(mch*))gc_sweep69},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc69))-1)}; + +T69*new69(void){ +gc69*n; +fsoc*c; +if(store_left69>1){ +store_left69--; +n=store69++; +} +else if(gc_free69!=NULL){ +n=gc_free69; +gc_free69=n->header.next; +} +else if(store_left69==1){ +store_left69=0; +store_chunk69->header.state_type=FSO_USED_CHUNK; +n=store69++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free69!=NULL){ +n=gc_free69; +gc_free69=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk69=c; +*store_chunk69=H69; +store69=((gc69*)(&(store_chunk69->first_object))); +store_left69=H69.count_minus_one; +n=store69++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M69; +return((T69*)n); +}/*--*/ + +void gc_mark9(T9 o){ +if(NULL==gc_find_chunk(o)) +return; /* external NA */ +(((rsoh*)o)-1)->header.magic_flag=RSOH_MARKED; +}/*--*/ + +T9 new9(unsigned int size){ +size=(size*sizeof(T3))+sizeof(rsoh); +size=((size+(sizeof(double)-1))&~(sizeof(double)-1)); +if (size<=(na_env9.store_left)){ +rsoh*r=na_env9.store; +na_env9.store_left-=size; +if(na_env9.store_left>sizeof(rsoh)){ +r->header.size=size; +na_env9.store=((rsoh*)(((char*)(na_env9.store))+size)); +} +else { +r->header.size=size+na_env9.store_left; +na_env9.store_left=0; +} +(r->header.magic_flag)=RSOH_UNMARKED; +((void)memset((r+1),0,r->header.size-sizeof(rsoh))); +return((T9)(r+1)); +} +return((T9)new_na(&na_env9,size)); +}/*--*/ + +void gc_sweep7(fsoc*c){ +gc7*o1,*o2; +o1=((gc7*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free7; +gc_free7=o1; +} +} +} +else{ +int dead=1; +gc7* old_gc_free = gc_free7; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free7; +gc_free7=o1; +} +} +if (dead){ +gc_free7 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark7(T7*o){ +if(((gc7*)o)->header.flag==FSOH_UNMARKED){ +((gc7*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_storage)gc_mark9((o->_storage)); +} +}/*--*/ + +void gc_align_mark7(fsoc*c,gc7*p){ +gc7*b=((gc7*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store7)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T7*o=(&(p->object)); +((gc7*)o)->header.flag=FSOH_MARKED; +/*3p*/if(NULL!=o->_storage)gc_mark9((o->_storage)); +} +} +}/*--*/ +fsoc H7={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark7, +(void(*)(mch*))gc_sweep7},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc7))-1)}; + +T7*new7(void){ +gc7*n; +fsoc*c; +if(store_left7>1){ +store_left7--; +n=store7++; +} +else if(gc_free7!=NULL){ +n=gc_free7; +gc_free7=n->header.next; +} +else if(store_left7==1){ +store_left7=0; +store_chunk7->header.state_type=FSO_USED_CHUNK; +n=store7++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free7!=NULL){ +n=gc_free7; +gc_free7=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk7=c; +*store_chunk7=H7; +store7=((gc7*)(&(store_chunk7->first_object))); +store_left7=H7.count_minus_one; +n=store7++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M7; +return((T7*)n); +}/*--*/ + +void gc_sweep70(fsoc*c){ +gc70*o1,*o2; +o1=((gc70*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free70; +gc_free70=o1; +} +} +} +else{ +int dead=1; +gc70* old_gc_free = gc_free70; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free70; +gc_free70=o1; +} +} +if (dead){ +gc_free70 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark70(T70*o){ +if(((gc70*)o)->header.flag==FSOH_UNMARKED){ +((gc70*)o)->header.flag=FSOH_MARKED; +/*i11p*/if(NULL!=o->_ready_message_)gc_mark7((T7*)(o->_ready_message_)); +/*i11p*/if(NULL!=o->_application_name_)gc_mark7((T7*)(o->_application_name_)); +/*i11p*/if(NULL!=o->_ivy_clients)gc_mark207((T207*)(o->_ivy_clients)); +/*i11p*/if(NULL!=o->_events_set)gc_mark147((T147*)(o->_events_set)); +/*i11p*/if(NULL!=o->_tmp_client_list)gc_mark207((T207*)(o->_tmp_client_list)); +/*i11p*/if(NULL!=o->_callback_list)gc_mark208((T208*)(o->_callback_list)); +/*i11p*/if(NULL!=o->_pattern_list)gc_mark211((T211*)(o->_pattern_list)); +} +}/*--*/ + +void gc_align_mark70(fsoc*c,gc70*p){ +gc70*b=((gc70*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store70)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T70*o=(&(p->object)); +((gc70*)o)->header.flag=FSOH_MARKED; +/*i11p*/if(NULL!=o->_ready_message_)gc_mark7((T7*)(o->_ready_message_)); +/*i11p*/if(NULL!=o->_application_name_)gc_mark7((T7*)(o->_application_name_)); +/*i11p*/if(NULL!=o->_ivy_clients)gc_mark207((T207*)(o->_ivy_clients)); +/*i11p*/if(NULL!=o->_events_set)gc_mark147((T147*)(o->_events_set)); +/*i11p*/if(NULL!=o->_tmp_client_list)gc_mark207((T207*)(o->_tmp_client_list)); +/*i11p*/if(NULL!=o->_callback_list)gc_mark208((T208*)(o->_callback_list)); +/*i11p*/if(NULL!=o->_pattern_list)gc_mark211((T211*)(o->_pattern_list)); +} +} +}/*--*/ +fsoc H70={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark70, +(void(*)(mch*))gc_sweep70},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc70))-1)}; + +T70*new70(void){ +gc70*n; +fsoc*c; +if(store_left70>1){ +store_left70--; +n=store70++; +} +else if(gc_free70!=NULL){ +n=gc_free70; +gc_free70=n->header.next; +} +else if(store_left70==1){ +store_left70=0; +store_chunk70->header.state_type=FSO_USED_CHUNK; +n=store70++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free70!=NULL){ +n=gc_free70; +gc_free70=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk70=c; +*store_chunk70=H70; +store70=((gc70*)(&(store_chunk70->first_object))); +store_left70=H70.count_minus_one; +n=store70++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M70; +return((T70*)n); +}/*--*/ + +void gc_sweep64(fsoc*c){ +gc64*o1,*o2; +o1=((gc64*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free64; +gc_free64=o1; +} +} +} +else{ +int dead=1; +gc64* old_gc_free = gc_free64; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free64; +gc_free64=o1; +} +} +if (dead){ +gc_free64 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark64(T64*o){ +if(((gc64*)o)->header.flag==FSOH_UNMARKED){ +((gc64*)o)->header.flag=FSOH_MARKED; +/*6p*/if(NULL!=o->_widget)gc_mark227((T227*)(o->_widget)); +/*6p*/if(NULL!=o->_graphic_connection)gc_mark131((T131*)(o->_graphic_connection)); +/*6p*/if(NULL!=o->_event_catcher)gc_mark128((T128*)(o->_event_catcher)); +/*6p*/if(NULL!=o->_loop_stack)gc_mark130((T130*)(o->_loop_stack)); +} +}/*--*/ + +void gc_align_mark64(fsoc*c,gc64*p){ +gc64*b=((gc64*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store64)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T64*o=(&(p->object)); +((gc64*)o)->header.flag=FSOH_MARKED; +/*6p*/if(NULL!=o->_widget)gc_mark227((T227*)(o->_widget)); +/*6p*/if(NULL!=o->_graphic_connection)gc_mark131((T131*)(o->_graphic_connection)); +/*6p*/if(NULL!=o->_event_catcher)gc_mark128((T128*)(o->_event_catcher)); +/*6p*/if(NULL!=o->_loop_stack)gc_mark130((T130*)(o->_loop_stack)); +} +} +}/*--*/ +fsoc H64={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark64, +(void(*)(mch*))gc_sweep64},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc64))-1)}; + +T64*new64(void){ +gc64*n; +fsoc*c; +if(store_left64>1){ +store_left64--; +n=store64++; +} +else if(gc_free64!=NULL){ +n=gc_free64; +gc_free64=n->header.next; +} +else if(store_left64==1){ +store_left64=0; +store_chunk64->header.state_type=FSO_USED_CHUNK; +n=store64++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free64!=NULL){ +n=gc_free64; +gc_free64=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk64=c; +*store_chunk64=H64; +store64=((gc64*)(&(store_chunk64->first_object))); +store_left64=H64.count_minus_one; +n=store64++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M64; +return((T64*)n); +}/*--*/ + +void gc_sweep25(fsoc*c){ +gc25*o1,*o2; +o1=((gc25*)(&(c->first_object))); +if(c->header.state_type==FSO_STORE_CHUNK){ +for(;o1header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +} +else{ +o1->header.next=gc_free25; +gc_free25=o1; +} +} +} +else{ +int dead=1; +gc25* old_gc_free = gc_free25; +o2=o1+c->count_minus_one; +for(;o1<=o2;o1++){ +if((o1->header.flag)==FSOH_MARKED){ +o1->header.flag=FSOH_UNMARKED; +dead=0;} +else{ +o1->header.next=gc_free25; +gc_free25=o1; +} +} +if (dead){ +gc_free25 = old_gc_free; +c->next=fsocfl; +fsocfl=c; +c->header.state_type=FSO_FREE_CHUNK; +} +} +}/*--*/ + +void gc_mark25(T25*o){ +if(((gc25*)o)->header.flag==FSOH_UNMARKED){ +((gc25*)o)->header.flag=FSOH_MARKED; +/*8p*/if(NULL!=o->_ivy)gc_mark70((T70*)(o->_ivy)); +/*8p*/if(NULL!=o->_screen)gc_mark72((T72*)(o->_screen)); +/*8p*/if(NULL!=o->_device_id)gc_mark7((T7*)(o->_device_id)); +/*8p*/if(NULL!=o->_application_name)gc_mark7((T7*)(o->_application_name)); +/*8p*/if(NULL!=o->_ivy_bus)gc_mark7((T7*)(o->_ivy_bus)); +} +}/*--*/ + +void gc_align_mark25(fsoc*c,gc25*p){ +gc25*b=((gc25*)(&(c->first_object))); +if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store25)))return; +if(((char*)p)>((char*)(b+(c->count_minus_one))))return; +if(((char*)p)<((char*)b))return; +if(((((char*)p)-((char*)b))%sizeof(*p))==0){ +if(p->header.flag==FSOH_UNMARKED){ +T25*o=(&(p->object)); +((gc25*)o)->header.flag=FSOH_MARKED; +/*8p*/if(NULL!=o->_ivy)gc_mark70((T70*)(o->_ivy)); +/*8p*/if(NULL!=o->_screen)gc_mark72((T72*)(o->_screen)); +/*8p*/if(NULL!=o->_device_id)gc_mark7((T7*)(o->_device_id)); +/*8p*/if(NULL!=o->_application_name)gc_mark7((T7*)(o->_application_name)); +/*8p*/if(NULL!=o->_ivy_bus)gc_mark7((T7*)(o->_ivy_bus)); +} +} +}/*--*/ +fsoc H25={{FSOC_SIZE,FSO_STORE_CHUNK, +(void(*)(mch*,void*))gc_align_mark25, +(void(*)(mch*))gc_sweep25},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc25))-1)}; + +T25*new25(void){ +gc25*n; +fsoc*c; +if(store_left25>1){ +store_left25--; +n=store25++; +} +else if(gc_free25!=NULL){ +n=gc_free25; +gc_free25=n->header.next; +} +else if(store_left25==1){ +store_left25=0; +store_chunk25->header.state_type=FSO_USED_CHUNK; +n=store25++; +} +else{ +c=gc_fsoc_get1(); +if(gc_free25!=NULL){ +n=gc_free25; +gc_free25=n->header.next; +} +else{ +if(c==NULL)c=gc_fsoc_get2(); +store_chunk25=c; +*store_chunk25=H25; +store25=((gc25*)(&(store_chunk25->first_object))); +store_left25=H25.count_minus_one; +n=store25++; +} +} +n->header.flag=FSOH_UNMARKED; +n->object=M25; +return((T25*)n); +}/*--*/ + +void Xgc_mark242(T0*o){ +{int i=o->id; +if (i <= 258) { +if (i <= 249) { +if (i <= 245) { +if (i <= 243) { +gc_mark243((T243*)o); +} +else{ +gc_mark245((T245*)o); +}} +else{ +gc_mark249((T249*)o); +}} +else{ +if (i <= 253) { +gc_mark253((T253*)o); +} +else{ +gc_mark258((T258*)o); +}}} +else{ +if (i <= 271) { +if (i <= 268) { +if (i <= 265) { +gc_mark265((T265*)o); +} +else{ +gc_mark268((T268*)o); +}} +else{ +gc_mark271((T271*)o); +}} +else{ +if (i <= 277) { +gc_mark277((T277*)o); +} +else{ +gc_mark286((T286*)o); +}}}}}/*--*/ + +void Xgc_mark49(T0*o){ +{int i=o->id; +if (i <= 131) { +gc_mark131((T131*)o); +} +else{ +gc_mark146((T146*)o); +}}}/*--*/ + +void Xgc_mark71(T0*o){ +{int i=o->id; +if (i <= 70) { +gc_mark70((T70*)o); +} +else{ +gc_mark128((T128*)o); +}}}/*--*/ +T25*eiffel_root_object=(void*)0; +int se_argc; +char**se_argv; +T7*g[294]; +T7*t[294]; +int se_strucT[294]={0,sizeof(T1),sizeof(T2),sizeof(T3),0,sizeof(T5),sizeof(T6),sizeof(T7),sizeof(T8),sizeof(T9),sizeof(T10), +sizeof(T11), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T25), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T43), +0, +0, +sizeof(T46), +0, +0, +0, +0, +0, +0, +sizeof(T53), +sizeof(T54), +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T64), +0, +0, +sizeof(T67), +0, +sizeof(T69), +sizeof(T70), +0, +sizeof(T72), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T110), +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T120), +0, +0, +0, +0, +0, +0, +0, +sizeof(T128), +0, +sizeof(T130), +sizeof(T131), +0, +0, +0, +0, +0, +0, +0, +sizeof(T139), +0, +sizeof(T141), +sizeof(T142), +sizeof(T143), +0, +0, +sizeof(T146), +sizeof(T147), +sizeof(T148), +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T158), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T175), +sizeof(T176), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T189), +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +0, +sizeof(T202), +0, +sizeof(T204), +sizeof(T205), +sizeof(T206), +sizeof(T207), +sizeof(T208), +0, +0, +sizeof(T211), +sizeof(T212), +sizeof(T213), +sizeof(T214), +sizeof(T215), +sizeof(T216), +sizeof(T217), +sizeof(T218), +sizeof(T219), +sizeof(T220), +sizeof(T221), +sizeof(T222), +sizeof(T223), +0, +sizeof(T225), +sizeof(T226), +sizeof(T227), +sizeof(T228), +0, +sizeof(T230), +0, +sizeof(T232), +0, +sizeof(T234), +sizeof(T235), +sizeof(T236), +sizeof(T237), +sizeof(T238), +sizeof(T239), +0, +0, +0, +sizeof(T243), +sizeof(T244), +sizeof(T245), +sizeof(T246), +sizeof(T247), +0, +sizeof(T249), +sizeof(T250), +sizeof(T251), +sizeof(T252), +sizeof(T253), +sizeof(T254), +sizeof(T255), +sizeof(T256), +sizeof(T257), +sizeof(T258), +sizeof(T259), +sizeof(T260), +sizeof(T261), +sizeof(T262), +sizeof(T263), +sizeof(T264), +sizeof(T265), +sizeof(T266), +sizeof(T267), +sizeof(T268), +0, +sizeof(T270), +sizeof(T271), +0, +0, +0, +0, +sizeof(T276), +sizeof(T277), +0, +0, +0, +sizeof(T281), +0, +0, +sizeof(T284), +0, +sizeof(T286), +sizeof(T287), +sizeof(T288), +sizeof(T289), +sizeof(T290), +sizeof(T291), +sizeof(T292), +sizeof(T293)}; + +void se_atexit(void){ +r53se_atexit(); +}/*--*/ + +void initialize_eiffel_runtime(int argc,char*argv[]){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +se_argc=argc; +se_argv=argv; +atexit(se_atexit); +gcmt=((mch**)se_malloc((gcmt_max+1)*sizeof(void*))); +#ifdef FIXED_STACK_BOTTOM +if (!stack_bottom) stack_bottom=((void**)(void*)(&argc)); +#endif +g[25]=(T7*)se_string("XINPUT_IVY"); +g[69]=(T7*)se_string("WACOM_POINTER"); +g[146]=(T7*)se_string("IVY_CLIENT"); +g[70]=(T7*)se_string("IVY"); +g[143]=(T7*)se_string("X11"); +g[67]=(T7*)se_string("X_INPUT_DEVICE"); +g[175]=(T7*)se_string("X_INPUT_EXTENSION"); +g[142]=(T7*)se_string("BUTTON_RANGE"); +g[141]=(T7*)se_string("AXES_RANGE"); +g[139]=(T7*)se_string("KEY_RANGE"); +g[123]=(T7*)se_string("PROCEDURE"); +g[15]=(T7*)se_string("TUPLE 1"); +g[16]=(T7*)se_string("TUPLE 2"); +g[115]=(T7*)se_string("ROUTINE"); +g[17]=(T7*)se_string("TUPLE 3"); +g[18]=(T7*)se_string("TUPLE 4"); +g[19]=(T7*)se_string("TUPLE 5"); +g[20]=(T7*)se_string("TUPLE 6"); +g[21]=(T7*)se_string("TUPLE 7"); +g[22]=(T7*)se_string("TUPLE 8"); +g[23]=(T7*)se_string("TUPLE 9"); +g[14]=(T7*)se_string("TUPLE"); +g[24]=(T7*)se_string("TUPLE 10"); +g[8]=(T7*)se_string("POINTER"); +g[199]=(T7*)se_string("REFERENCE"); +g[30]=(T7*)se_string("ARGUMENTS"); +g[114]=(T7*)se_string("FUNCTION"); +g[6]=(T7*)se_string("BOOLEAN"); +g[98]=(T7*)se_string("SAFE_EQUAL"); +g[13]=(T7*)se_string("ANY"); +g[173]=(T7*)se_string("WEAK_REFERENCE"); +g[42]=(T7*)se_string("PLATFORM"); +g[121]=(T7*)se_string("INTERNALS_HANDLER"); +g[169]=(T7*)se_string("NATIVE_ARRAY_INTERNALS"); +g[51]=(T7*)se_string("TYPED_INTERNALS"); +g[57]=(T7*)se_string("NATIVE_ARRAY_COLLECTOR"); +g[52]=(T7*)se_string("INTERNALS"); +g[56]=(T7*)se_string("COLLECTION"); +g[166]=(T7*)se_string("STACK"); +g[137]=(T7*)se_string("SIMPLE_DICTIONARY"); +g[124]=(T7*)se_string("DICTIONARY"); +g[55]=(T7*)se_string("FAST_ARRAY"); +g[116]=(T7*)se_string("ARRAY"); +g[144]=(T7*)se_string("RING_ARRAY"); +g[136]=(T7*)se_string("HASHED_DICTIONARY"); +g[97]=(T7*)se_string("NATIVE_ARRAY"); +g[165]=(T7*)se_string("RECYCLING_POOL"); +g[172]=(T7*)se_string("ANY_HASHED_DICTIONARY_NODE"); +g[58]=(T7*)se_string("ARRAYED_COLLECTION"); +g[171]=(T7*)se_string("HASHED_DICTIONARY_NODE"); +g[138]=(T7*)se_string("HASH_TABLE_SIZE"); +g[96]=(T7*)se_string("FILTER"); +g[31]=(T7*)se_string("OUTPUT_STREAM"); +g[119]=(T7*)se_string("FILTER_INPUT_STREAM"); +g[44]=(T7*)se_string("TERMINAL_OUTPUT_STREAM"); +g[48]=(T7*)se_string("TERMINAL_INPUT_STREAM"); +g[47]=(T7*)se_string("TERMINAL_INPUT_OUTPUT_STREAM"); +g[111]=(T7*)se_string("FILTER_OUTPUT_STREAM"); +g[49]=(T7*)se_string("INPUT_STREAM"); +g[32]=(T7*)se_string("STREAM"); +g[108]=(T7*)se_string("FILE"); +g[107]=(T7*)se_string("TEXT_FILE_READ"); +g[46]=(T7*)se_string("STD_INPUT_OUTPUT"); +g[43]=(T7*)se_string("STD_ERROR"); +g[54]=(T7*)se_string("STD_INPUT"); +g[53]=(T7*)se_string("STD_OUTPUT"); +g[50]=(T7*)se_string("INPUT_STREAM_TOOLS"); +g[36]=(T7*)se_string("OUTPUT_STREAM_TOOLS"); +g[45]=(T7*)se_string("REDIRECTION_TOOLS"); +g[35]=(T7*)se_string("FILTERABLE"); +g[66]=(T7*)se_string("UNICODE_STRING_HANDLER"); +g[113]=(T7*)se_string("ITERATOR"); +g[122]=(T7*)se_string("ITERATOR_ON_TRAVERSABLE"); +g[167]=(T7*)se_string("ITERATOR_ON_UNICODE_STRING"); +g[170]=(T7*)se_string("ITERATOR_ON_DICTIONARY_ITEMS"); +g[118]=(T7*)se_string("ITERATOR_ON_STRING"); +g[174]=(T7*)se_string("ITERATOR_ON_DICTIONARY_KEYS"); +g[168]=(T7*)se_string("MINI_PARSER_BUFFER"); +g[125]=(T7*)se_string("SIGNAL_0"); +g[140]=(T7*)se_string("SIGNAL_1"); +g[126]=(T7*)se_string("SIGNAL_2"); +g[127]=(T7*)se_string("SIGNAL_4"); +g[147]=(T7*)se_string("EVENTS_SET"); +g[148]=(T7*)se_string("LOOP_ITEM"); +g[109]=(T7*)se_string("EVENT_DESCRIPTOR"); +g[71]=(T7*)se_string("JOB"); +g[129]=(T7*)se_string("LOOP_STACK"); +g[120]=(T7*)se_string("CAN_READ_DATA_FROM_STREAM"); +g[195]=(T7*)se_string("NETWORK_CONNECTION_OCCURRED"); +g[110]=(T7*)se_string("STREAM_EXCEPTION"); +g[112]=(T7*)se_string("CAN_WRITE_DATA_TO_STREAM"); +g[74]=(T7*)se_string("CONTAINER"); +g[130]=(T7*)se_string("VISION_LOOP_STACK"); +g[61]=(T7*)se_string("ALIGNMENT"); +g[28]=(T7*)se_string("STATE_CONSTANTS"); +g[155]=(T7*)se_string("PIXMAP"); +g[75]=(T7*)se_string("SENSITIVE"); +g[134]=(T7*)se_string("DRAW_STYLE"); +g[77]=(T7*)se_string("WIDGET"); +g[135]=(T7*)se_string("DRAWABLE_HANDLER"); +g[27]=(T7*)se_string("ALIGNMENT_CONSTANTS"); +g[198]=(T7*)se_string("LABEL"); +g[131]=(T7*)se_string("GRAPHIC_CONNECTION"); +g[68]=(T7*)se_string("EXTENSION_DEVICE"); +g[64]=(T7*)se_string("VISION"); +g[133]=(T7*)se_string("DRAW_KIT"); +g[78]=(T7*)se_string("STATE"); +g[76]=(T7*)se_string("DRAWABLE"); +g[65]=(T7*)se_string("BASIC_FONT"); +g[63]=(T7*)se_string("FONT_MANAGER"); +g[26]=(T7*)se_string("GRAPHIC"); +g[132]=(T7*)se_string("RECT"); +g[128]=(T7*)se_string("EVENT_CATCHER"); +g[181]=(T7*)se_string("BUTTON"); +g[62]=(T7*)se_string("COLOR"); +g[29]=(T7*)se_string("COLOR_LIST"); +g[81]=(T7*)se_string("WHEN_UNMAPPED"); +g[184]=(T7*)se_string("POINTER_STATUS"); +g[95]=(T7*)se_string("WHEN_LEFT_DOWN"); +g[93]=(T7*)se_string("WHEN_MIDDLE_DOWN"); +g[90]=(T7*)se_string("WHEN_RIGHT_UP"); +g[80]=(T7*)se_string("WHEN_GEOMETRY_CHANGE"); +g[82]=(T7*)se_string("WHEN_MAPPED"); +g[182]=(T7*)se_string("WHEN_DOUBLE_CLICKED"); +g[91]=(T7*)se_string("WHEN_RIGHT_DOWN"); +g[157]=(T7*)se_string("WHEN_CLOSE_REQUESTED"); +g[84]=(T7*)se_string("WHEN_KEY_DOWN"); +g[186]=(T7*)se_string("WHEN_RIGHT_CLICKED"); +g[94]=(T7*)se_string("WHEN_LEFT_UP"); +g[187]=(T7*)se_string("WHEN_MIDDLE_CLICKED"); +g[83]=(T7*)se_string("WHEN_KEY_UP"); +g[85]=(T7*)se_string("WHEN_POINTER_LEAVE"); +g[79]=(T7*)se_string("WHEN_EXPOSE"); +g[183]=(T7*)se_string("WHEN_LEFT_CLICKED"); +g[88]=(T7*)se_string("WHEN_WHEEL_DOWN"); +g[86]=(T7*)se_string("WHEN_POINTER_ENTER"); +g[89]=(T7*)se_string("WHEN_WHEEL_UP"); +g[92]=(T7*)se_string("WHEN_MIDDLE_UP"); +g[87]=(T7*)se_string("WHEN_POINTER_MOVE"); +g[188]=(T7*)se_string("COLUMN_LAYOUT"); +g[180]=(T7*)se_string("CHECK_SPACE"); +g[154]=(T7*)se_string("LAYOUT"); +g[158]=(T7*)se_string("ROOT_LAYOUT"); +g[196]=(T7*)se_string("ROW_LAYOUT"); +g[201]=(T7*)se_string("BUTTON_SPACE"); +g[150]=(T7*)se_string("RENDERER"); +g[152]=(T7*)se_string("BASIC_RENDERER"); +g[151]=(T7*)se_string("CLASSIC_RENDERER"); +g[149]=(T7*)se_string("DEFAULT_RENDERER"); +g[185]=(T7*)se_string("SUB_WINDOW"); +g[156]=(T7*)se_string("TOPLEVEL_WINDOW"); +g[197]=(T7*)se_string("SCROLL_VIEW"); +g[73]=(T7*)se_string("WINDOW"); +g[72]=(T7*)se_string("ROOT_WINDOW"); +g[34]=(T7*)se_string("RECYCLABLE"); +g[33]=(T7*)se_string("DISPOSABLE"); +g[38]=(T7*)se_string("TRAVERSABLE"); +g[41]=(T7*)se_string("HASHABLE"); +g[39]=(T7*)se_string("STORABLE"); +g[40]=(T7*)se_string("COMPARABLE"); +g[12]=(T7*)se_string("REAL_EXTENDED"); +g[145]=(T7*)se_string("MATH_CONSTANTS"); +g[101]=(T7*)se_string("REAL_GENERAL"); +g[104]=(T7*)se_string("NATURAL_64"); +g[2]=(T7*)se_string("INTEGER_32"); +g[105]=(T7*)se_string("NUMBER"); +g[4]=(T7*)se_string("REAL_32"); +g[1]=(T7*)se_string("INTEGER_8"); +g[161]=(T7*)se_string("MUTABLE_BIG_INTEGER"); +g[11]=(T7*)se_string("INTEGER_64"); +g[117]=(T7*)se_string("NUMBER_TOOLS"); +g[59]=(T7*)se_string("INTEGER_GENERAL"); +g[5]=(T7*)se_string("REAL_64"); +g[99]=(T7*)se_string("NATURAL_16"); +g[60]=(T7*)se_string("NUMERIC"); +g[103]=(T7*)se_string("NATURAL_32"); +g[102]=(T7*)se_string("NATURAL_8"); +g[100]=(T7*)se_string("NATURAL_GENERAL"); +g[10]=(T7*)se_string("INTEGER_16"); +g[162]=(T7*)se_string("FRACTION_WITH_BIG_INTEGER_NUMBER"); +g[159]=(T7*)se_string("INTEGER_64_NUMBER"); +g[160]=(T7*)se_string("INTEGER_GENERAL_NUMBER"); +g[163]=(T7*)se_string("FRACTION_GENERAL_NUMBER"); +g[164]=(T7*)se_string("BIG_INTEGER_NUMBER"); +g[106]=(T7*)se_string("UNICODE_STRING"); +g[3]=(T7*)se_string("CHARACTER"); +g[7]=(T7*)se_string("STRING"); +g[37]=(T7*)se_string("STRING_HANDLER"); +g[189]=(T7*)se_string("TIME"); +g[176]=(T7*)se_string("MICROSECOND_TIME"); +g[190]=(T7*)se_string("TIME_HANDLER"); +g[192]=(T7*)se_string("ACCESS"); +g[194]=(T7*)se_string("SOCKET_INPUT_OUTPUT_STREAM"); +g[177]=(T7*)se_string("SOCKET_SERVER"); +g[200]=(T7*)se_string("CLIENT_SOCKET_INPUT_OUTPUT_STREAM"); +g[193]=(T7*)se_string("SERVER_SOCKET_INPUT_OUTPUT_STREAM"); +g[178]=(T7*)se_string("SOCKET_PLUG_IN"); +g[179]=(T7*)se_string("SOCKET_HANDLER"); +g[191]=(T7*)se_string("SOCKET"); +g[153]=(T7*)se_string("SYSTEM"); +g[293]=g[97]; +g[292]=g[97]; +g[291]=g[97]; +g[290]=g[97]; +g[289]=g[97]; +g[288]=g[97]; +g[287]=g[97]; +g[286]=g[173]; +g[284]=g[97]; +g[281]=g[97]; +g[277]=g[173]; +g[276]=g[97]; +g[271]=g[173]; +g[270]=g[97]; +g[268]=g[173]; +g[267]=g[97]; +g[266]=g[171]; +g[265]=g[173]; +g[264]=g[171]; +g[263]=g[97]; +g[262]=g[97]; +g[261]=g[97]; +g[260]=g[97]; +g[259]=g[97]; +g[258]=g[173]; +g[257]=g[97]; +g[256]=g[171]; +g[255]=g[97]; +g[254]=g[55]; +g[253]=g[173]; +g[252]=g[171]; +g[251]=g[97]; +g[250]=g[97]; +g[249]=g[173]; +g[247]=g[97]; +g[246]=g[171]; +g[245]=g[173]; +g[244]=g[136]; +g[243]=g[173]; +g[239]=g[97]; +g[238]=g[97]; +g[237]=g[97]; +g[236]=g[55]; +g[235]=g[55]; +g[234]=g[136]; +g[232]=g[55]; +g[230]=g[136]; +g[228]=g[136]; +g[227]=g[136]; +g[226]=g[136]; +g[225]=g[55]; +g[223]=g[55]; +g[222]=g[55]; +g[221]=g[55]; +g[220]=g[97]; +g[219]=g[97]; +g[218]=g[136]; +g[217]=g[55]; +g[216]=g[140]; +g[215]=g[136]; +g[214]=g[55]; +g[213]=g[144]; +g[212]=g[97]; +g[211]=g[136]; +g[208]=g[136]; +g[207]=g[55]; +g[206]=g[55]; +g[205]=g[55]; +g[204]=g[55]; +g[202]=g[123]; +g[9]=g[97]; +t[293]=(T7*)se_string("NATIVE_ARRAY[PROCEDURE[TUPLE]]"); +t[292]=(T7*)se_string("NATIVE_ARRAY[PROCEDURE[TUPLE[INTEGER_32,INTEGER_32]]]"); +t[291]=(T7*)se_string("NATIVE_ARRAY[PROCEDURE[TUPLE[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32]]]"); +t[290]=(T7*)se_string("NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]"); +t[289]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]"); +t[288]=(T7*)se_string("NATIVE_ARRAY[JOB]"); +t[287]=(T7*)se_string("NATIVE_ARRAY[EVENT_CATCHER]"); +t[286]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]"); +t[284]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]"); +t[281]=(T7*)se_string("NATIVE_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]"); +t[277]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]"); +t[276]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]"); +t[271]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]"); +t[270]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]"); +t[268]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]"); +t[267]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]"); +t[266]=(T7*)se_string("HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]"); +t[265]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]"); +t[264]=(T7*)se_string("HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]"); +t[263]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]"); +t[262]=(T7*)se_string("NATIVE_ARRAY[TOPLEVEL_WINDOW]"); +t[261]=(T7*)se_string("NATIVE_ARRAY[KEY_RANGE]"); +t[260]=(T7*)se_string("NATIVE_ARRAY[BUTTON_RANGE]"); +t[259]=(T7*)se_string("NATIVE_ARRAY[AXES_RANGE]"); +t[258]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]"); +t[257]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]"); +t[256]=(T7*)se_string("HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]"); +t[255]=(T7*)se_string("NATIVE_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]"); +t[254]=(T7*)se_string("FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]"); +t[253]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]"); +t[252]=(T7*)se_string("HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]"); +t[251]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]"); +t[250]=(T7*)se_string("NATIVE_ARRAY[INTEGER_32]"); +t[249]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[POINTER,STRING]]"); +t[247]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[POINTER,STRING]]"); +t[246]=(T7*)se_string("HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]"); +t[245]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]"); +t[244]=(T7*)se_string("HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]"); +t[243]=(T7*)se_string("WEAK_REFERENCE[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]"); +t[239]=(T7*)se_string("NATIVE_ARRAY[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]"); +t[238]=(T7*)se_string("NATIVE_ARRAY[IVY_CLIENT]"); +t[237]=(T7*)se_string("NATIVE_ARRAY[LOOP_ITEM]"); +t[236]=(T7*)se_string("FAST_ARRAY[JOB]"); +t[235]=(T7*)se_string("FAST_ARRAY[EVENT_CATCHER]"); +t[234]=(T7*)se_string("HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]"); +t[232]=(T7*)se_string("FAST_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]"); +t[230]=(T7*)se_string("HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]"); +t[228]=(T7*)se_string("HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]"); +t[227]=(T7*)se_string("HASHED_DICTIONARY[SENSITIVE,POINTER]"); +t[226]=(T7*)se_string("HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]"); +t[225]=(T7*)se_string("FAST_ARRAY[TOPLEVEL_WINDOW]"); +t[223]=(T7*)se_string("FAST_ARRAY[KEY_RANGE]"); +t[222]=(T7*)se_string("FAST_ARRAY[BUTTON_RANGE]"); +t[221]=(T7*)se_string("FAST_ARRAY[AXES_RANGE]"); +t[220]=(T7*)se_string("NATIVE_ARRAY[X_INPUT_DEVICE]"); +t[219]=(T7*)se_string("NATIVE_ARRAY[STRING]"); +t[218]=(T7*)se_string("HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]"); +t[217]=(T7*)se_string("FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]"); +t[216]=(T7*)se_string("SIGNAL_1[X_INPUT_DEVICE]"); +t[215]=(T7*)se_string("HASHED_DICTIONARY[INTEGER_32,INTEGER_32]"); +t[214]=(T7*)se_string("FAST_ARRAY[INTEGER_32]"); +t[213]=(T7*)se_string("RING_ARRAY[INTEGER_32]"); +t[212]=(T7*)se_string("NATIVE_ARRAY[POINTER]"); +t[211]=(T7*)se_string("HASHED_DICTIONARY[POINTER,STRING]"); +t[208]=(T7*)se_string("HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]"); +t[207]=(T7*)se_string("FAST_ARRAY[IVY_CLIENT]"); +t[206]=(T7*)se_string("FAST_ARRAY[LOOP_ITEM]"); +t[205]=(T7*)se_string("FAST_ARRAY[X_INPUT_DEVICE]"); +t[204]=(T7*)se_string("FAST_ARRAY[STRING]"); +t[202]=(T7*)se_string("PROCEDURE[TUPLE[X_INPUT_DEVICE]]"); +t[189]=g[189]; +t[176]=g[176]; +t[175]=g[175]; +t[158]=g[158]; +t[148]=g[148]; +t[147]=g[147]; +t[146]=g[146]; +t[143]=g[143]; +t[142]=g[142]; +t[141]=g[141]; +t[139]=g[139]; +t[131]=g[131]; +t[130]=g[130]; +t[128]=g[128]; +t[120]=g[120]; +t[110]=g[110]; +t[72]=g[72]; +t[70]=g[70]; +t[69]=g[69]; +t[67]=g[67]; +t[64]=g[64]; +t[54]=g[54]; +t[53]=g[53]; +t[46]=g[46]; +t[43]=g[43]; +t[25]=g[25]; +t[11]=g[11]; +t[10]=g[10]; +t[9]=(T7*)se_string("NATIVE_ARRAY[CHARACTER]"); +t[8]=g[8]; +t[7]=g[7]; +t[6]=g[6]; +t[5]=g[5]; +t[3]=g[3]; +t[2]=g[2]; +t[1]=g[1]; +#ifdef SIGQUIT +signal(SIGQUIT,se_signal_handler); +#endif +#ifdef SIGILL +signal(SIGILL,se_signal_handler); +#endif +#ifdef SIGABRT +signal(SIGABRT,se_signal_handler); +#endif +#ifdef SIGFPE +signal(SIGFPE,se_signal_handler); +#endif +#ifdef SIGSEGV +signal(SIGSEGV,se_signal_handler); +#endif +#ifdef SIGBUS +signal(SIGBUS,se_signal_handler); +#endif +#ifdef SIGSYS +signal(SIGSYS,se_signal_handler); +#endif +#ifdef SIGTRAP +signal(SIGTRAP,se_signal_handler); +#endif +#ifdef SIGXCPU +signal(SIGXCPU,se_signal_handler); +#endif +#ifdef SIGXFSZ +signal(SIGXFSZ,se_signal_handler); +#endif +se_msi1(); +/*PCO*/ +oBC101sprintf_buffer=new9(INT32_C(1024)); +/*PCO*/ +tmp0=((T0*)(new46())); +/*RF3E*/oBC13io=tmp0; +/*PCO*/ +tmp0=((T0*)(new43())); +oBC13std_error=tmp0; +gc_is_off=0; +tmp0=((T0*)(new25())); +r143default_create(); +eiffel_root_object=((T25*)tmp0); +}/*--*/ + +int main(int argc,char*argv[]){ +/*[INTERNAL_C_LOCAL list*/ +T0* tmp0; +/*INTERNAL_C_LOCAL list]*/ +stack_bottom=((void**)(void*)(&argc)); +initialize_eiffel_runtime(argc,argv); +tmp0=((T0*)eiffel_root_object); +r25make(((T25*)tmp0)); +gc_dispose_before_exit(); +handle(SE_HANDLE_NORMAL_EXIT, NULL); +exit(0); +return 0; +}/*--*/ + +void X71prepare(T0*C,T0* a1){ +{Tid id=((T0*)C)->id; +if(id<=70){ +r70prepare(((T70*)C),a1); +} +else{ +r128prepare(((T128*)C),a1); +}} +}/*--*/ + +T2 X71priority(T0*C){ +T2 R; +{Tid id=((T0*)C)->id; +if(id<=70){ +R=((/*RF2*/(((T70*)C))->_priority/*i11p*/)); +} +else{ +R=((/*RF2*/(((T128*)C))->_priority/*i11p*/)); +}} +return R; +}/*--*/ + +T6 X71done(T0*C){ +T6 R; +{Tid id=((T0*)C)->id; +if(id<=70){ +R=(T6)((/*RF2*/(((T70*)C))->_done/*i11p*/)); +} +else{ +R=(T6)((/*RF2*/(((T128*)C))->_done/*i11p*/)); +}} +return R; +}/*--*/ + +T6 X71is_ready(T0*C,T0* a1){ +T6 R; +{Tid id=((T0*)C)->id; +if(id<=70){ +R=(T6)(r70is_ready(((T70*)C),a1)); +} +else{ +R=(T6)(r128is_ready(((T128*)C),a1)); +}} +return R; +}/*--*/ + +void X71continue(T0*C){ +{Tid id=((T0*)C)->id; +if(id<=70){ +r70continue(((T70*)C)); +} +else{ +r128continue(((T128*)C)); +}} +}/*--*/ + +void X109expect(T0*C,T0* a1){ +{Tid id=((T0*)C)->id; +if(id<=110){ +r110expect(((T110*)C),a1); +} +else{ +r120expect(((T120*)C),a1); +}} +}/*--*/ + +T6 X109occurred(T0*C,T0* a1){ +T6 R; +{Tid id=((T0*)C)->id; +if(id<=110){ +R=(T6)(r110occurred(((T110*)C),a1)); +} +else{ +R=(T6)(r120occurred(((T120*)C),a1)); +}} +return R; +}/*--*/ + +T2 X49descriptor(T0*C){ +T2 R; +{Tid id=((T0*)C)->id; +if(id<=131){ +R=((/*RF2*/(((T131*)C))->_descriptor/*i2p*/)); +} +else{ +R=(r146descriptor(((T146*)C))); +}} +return R; +}/*--*/ + +T2 X49filtered_descriptor(T0*C){ +T2 R; +{Tid id=((T0*)C)->id; +if(id<=131){ +R=(r131filtered_descriptor(((T131*)C))); +} +else{ +R=((/*RF2*/(((T146*)C))->_filtered_descriptor/*i7p*/)); +}} +return R; +}/*--*/ + +#ifdef __cplusplus +} +#endif diff --git a/xinput_ivy.e b/xinput_ivy.e new file mode 100644 index 0000000..15d0a54 --- /dev/null +++ b/xinput_ivy.e @@ -0,0 +1,431 @@ +class XINPUT_IVY + +inherit + GRAPHIC + +insert + ARGUMENTS + +creation {ANY} + make + +feature {} + + ivy_bus: STRING + + application_name: STRING + + device_id: STRING + + make is + local + ready: BOOLEAN + do + application_name := "wacom" + ivy_bus := ":3110" + device_id := "default" + screen := vision.root_window + ready := decode_options + if ready then + create ivy.make(application_name) + ivy.start(ivy_bus) + vision.loop_stack.add_job(ivy) + vision.start + end + end + + screen: ROOT_WINDOW + + decode_options: BOOLEAN is + local + i: INTEGER + option, value: STRING + equal_index: INTEGER + error: BOOLEAN + tmp_pointer: WACOM_POINTER + do + from + i := 1 + option := "" + value := "" + create tmp_pointer.make(Current) + until + i > argument_count or error + loop + option.copy(argument(i)) + equal_index := option.first_index_of('=') + if equal_index = 0 then + value.clear_count + else + value.copy(option) + value.remove_head(equal_index) + option.remove_tail(option.count - equal_index + 1) + end + inspect option + when "-help" then + print_help + when "-list_devices" then + list_devices + when "-pad" then + if init_pad(value) then + Result := True + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid pad name.%N") + end + when "-wacom_pointer" then + if init_wacom_pointer(tmp_pointer, value) then + Result := True + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid pointer name.%N") + end + when "-bus" then + ivy_bus.copy(value) + when "-b" then + if i < argument_count then + i := i + 1 + ivy_bus.copy(argument(i)) + else + error := True + std_error.put_string("Missing bus identifier after % + %-b option.%N") + end + when "-application" then + application_name.copy(value) + when "-identifier" then + device_id.copy(value) + when "-x_offset" then + if value.is_integer then + tmp_pointer.set_x_offset(value.to_integer) + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid x_offset (an integer is needed).%N") + end + when "-y_offset" then + if value.is_integer then + tmp_pointer.set_y_offset(value.to_integer) + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid y_offset (an integer is needed).%N") + end + when "-prediction" then + if value.is_real then + tmp_pointer.set_prediction(value.to_real) + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid time (a real number is needed).%N") + end + when "-ignore" then + if value.is_integer then + tmp_pointer.set_ignore_rate(value.to_integer) + else + error := True + std_error.put_character('"') + std_error.put_string(value) + std_error.put_string("%" is not a valid ignore rate (an integer is needed).%N") + end + else + error := True + std_error.put_string("Unknown option ") + std_error.put_string(argument(i)) + std_error.put_new_line + print_help + end + i := i + 1 + end + if error then + Result := False + end + if argument_count =0 then + print_help + end + end + + init_pad(pad_name: STRING): BOOLEAN is + local + pad: X_INPUT_DEVICE + message_header: STRING + do + pad := subscribe_input(pad_name) + if pad /= Void then + Result := True + message_header := "slider_event device_id=" + message_header.append(device_id) + message_header.append(once " value=") + pad.when_moved(screen, agent slider_event(message_header, ?)) + pad.when_proximity_out(screen, agent left_slider_out(message_header, ?)) + + message_header := "pad_event device_id=" + message_header.append(device_id) + message_header.append(once " button=") + pad.when_button_pressed(screen, agent pad_button_pressed(message_header, ?)) + pad.when_button_released(screen, agent pad_button_released(message_header, ?)) + end + end + + init_wacom_pointer(wacom_pointer_model: WACOM_POINTER; pointer_name: STRING): BOOLEAN is + local + pointer: X_INPUT_DEVICE + message_header: STRING + wacom_pointer: WACOM_POINTER + do + pointer := subscribe_input(pointer_name) + if pointer /= Void then + Result := True + wacom_pointer := wacom_pointer_model.twin + message_header := "_event device_id=" + message_header.append(device_id) + wacom_pointer.set_message_header(message_header) + pointer.when_moved(screen, agent wacom_pointer.move) + pointer.when_button_pressed(screen, agent wacom_pointer.button(True, ?)) + pointer.when_button_released(screen, agent wacom_pointer.button(False, ?)) + pointer.when_proximity_in(screen, agent wacom_pointer.proximity(True, ?)) + pointer.when_proximity_out(screen, agent wacom_pointer.proximity(False, ?)) + end + end + + print_help is + do + io.put_string("[ + This tool get data from wacom pen screen and is + able to send them to applications using ivy bus. + + Options: + -help: print this help. + + -list_devices: all available devices are listed. + + -pad=name: report pad data from the pad device with this name. + + -wacom_pointer=name: report pointer data from the pointer device with + this name. Ex: stylus. + + -bus=[address]:port: specify the ivy bus (default is :3110). + + -b [address]:port: specify the ivy bus (default is :3110) (added for + compatibility with other ivy tools). + + -application=name: specify the application name on the ivy bus + (default is wacom). + + -identifier=id: this identifier will be used in ivy messages + device_id value (default is "default"). + + -x_offset=n: specify the x-offset for the wacom device + for the display configuration (default is 0). + + -y_offset=n: specify the y-offset for the wacom device + for the display configuration (default is 0). + + -prediction=t: change the prediction time for the physical position. + (default is 25ms). + + -ignore=n: number of messages to ignore before sending a new + position message (this reduces message frequency). + (default is 0 => ~120message/s). + + Options are considered in the order they appear in the command line. A new + value overrides the previous one. "wacom_pointer" and "pad" are created where they + appear, with known information. + + Messages: + slider_event device_id=radar_wacom value=4 side=left time=4523271 + device_id: identifier (see options). + value: new slider value (0 when the + finger leaves the slider). + side: left or right. + time: event time (ms), X server reference. + + pad_event device_id=radar_wacom button=12 status=left time=4523271 + device_id: identifier (see options). + button: button identifier. + status: up or down. + time: event time (ms), X server reference. + + button_event device_id=radar_wacom button=2 status=up x=1290 y=325 + presure=307 tilt_x=-20 tilt_y=15 wheel=0 predicted_x=1272 predicted_y=322 + type=123 serial_number=429389 time=4523271 hires_x=0.827 hires_y=0.231 + proximity=unchanged + pointer_event device_id=radar_wacom x=1290 y=325 + presure=307 tilt_x=-20 tilt_y=15 wheel=0 predicted_x=1272 predicted_y=322 + type=123 serial_number=429389 time=4523271 hires_x=0.827 hires_y=0.231 + proximity=unchanged + device_id: identifier (see options). + button: button identifier. + status: up or down. + x: pointer position (display coordinates). + y: pointer position (display coordinates). + presure: presure value ([0, 1023] for intuos 3). + tilt_x: device tilt in degrees. + tilt_y: device tilt in degrees. + wheel: rotation value (device type dependent value). + predicted_x: predicted position. It is expected to be + the current position of the real device. + predicted_y: predicted position. It is expected to be + the current position of the real device. + type: the type of the device (pen, eraser, mouse, + cursor, airbrush...). + serial_number: the serial number of the device. + time: event time (ms), X server reference. + hires_x: pointer position (device coordinates, in range [0,1]). + hires_y: pointer position (device coordinates, in range [0,1]). + proximity: unchanged, in, out + + ]") + --*** calibration? + --*** filtrage? + --*** bouton du stylo? + --*** distance du stylo? + --*** message pour demander la configuration? + --*** suppression du curseur souris + --*** display + --*** + --*** Ajouter le message pour modifier la prédiction + end + + x11: X11 + + subscribe_input(name: STRING): X_INPUT_DEVICE is + local + i: INTEGER + devices: FAST_ARRAY[X_INPUT_DEVICE] + do + if not x11.has_x_input_extension then + std_error.put_line("XInputExtension is not available.") + else + from + devices := x11.x_input_extension.devices + i := devices.lower + until + i > devices.upper or else Result /= Void + loop + if devices.item(i).name.is_equal(name) then + Result := devices.item(i) + if Result.is_available_extension then + Result.connect + else + Result := Void + end + end + i := i + 1 + end + end + end + + left_pad_position: INTEGER + right_pad_position: INTEGER + + slider_event(message_header: STRING; pad: X_INPUT_DEVICE) is + local + new_pad_position: INTEGER + message: STRING + do + message := once "" + new_pad_position := pad.motion_axis_data(4) + if new_pad_position /= left_pad_position then + message.copy(message_header) + new_pad_position.append_in(message) + message.append(once " side=left time=") + pad.event_time.append_in(message) + ivy.send_message(message) + left_pad_position := new_pad_position + end + + new_pad_position := pad.motion_axis_data(5) + if new_pad_position /= right_pad_position then + message.copy(message_header) + new_pad_position.append_in(message) + message.append(once " side=right time=") + pad.event_time.append_in(message) + ivy.send_message(message) + right_pad_position := new_pad_position + end + end + + left_slider_out(message_header: STRING; pad: X_INPUT_DEVICE) is + local + message: STRING + do + message := once "" + message.copy(message_header) + message.extend('0') + message.append(once " side=left time=") + pad.event_time.append_in(message) + ivy.send_message(message) + left_pad_position := 0 + end + + pad_button_pressed(message_header: STRING; pad: X_INPUT_DEVICE) is + local + message: STRING + do + message := once "" + message.copy(message_header) + pad.button_number.append_in(message) + message.append(once " status=down time=") + pad.event_time.append_in(message) + ivy.send_message(message) + end + + pad_button_released(message_header: STRING; pad: X_INPUT_DEVICE) is + local + message: STRING + do + message := once "" + message.copy(message_header) + pad.button_number.append_in(message) + message.append(once " status=up time=") + pad.event_time.append_in(message) + ivy.send_message(message) + end + + list_devices is + local + i: INTEGER + devices: FAST_ARRAY[X_INPUT_DEVICE] + device: X_INPUT_DEVICE + do + if not x11.has_x_input_extension then + std_error.put_line("XInputExtension is not available.") + else + from + devices := x11.x_input_extension.devices + i := devices.lower + until + i > devices.upper + loop + device := devices.item(i) + std_output.put_string(device.name) + std_output.put_string(once " (Type: ") + if device.type = Void then + std_output.put_character('?') + else + std_output.put_string(device.type) + end + std_output.put_string(once " Status: ") + if device.is_available_extension then + std_output.put_line(once " available)") + else + std_output.put_line(once " unavailable)") + end + i := i + 1 + end + end + end + +feature {WACOM_POINTER} + ivy: IVY + + +end diff --git a/xinput_ivy.h b/xinput_ivy.h new file mode 100644 index 0000000..c0d71a5 --- /dev/null +++ b/xinput_ivy.h @@ -0,0 +1,3249 @@ +#ifdef __cplusplus +extern "C" { +#endif +/* +ANSI C code generated by SmartEiffel The GNU Eiffel Compiler, Eiffel tools and libraries +Release 2.4 (??? September ??th 2007) [????] +Copyright (C), 1994-2002 - INRIA - LORIA - ESIAL UHP Nancy 1 - FRANCE +Copyright (C), 2003-2005 - INRIA - LORIA - IUT Charlemagne Nancy 2 - FRANCE +D.COLNET, P.RIBET, C.ADRIAN, V.CROIZIER F.MERIZEN - SmartEiffel@loria.fr +http://SmartEiffel.loria.fr +C Compiler options used: -pipe -O3 -fomit-frame-pointer +*/ + +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +/* + This file (SmartEiffel/sys/runtime/base.h) contains all basic Eiffel + type definitions. + This file is automatically included in the header for all modes of + compilation: -boost, -no_check, -require_check, -ensure_check, ... + This file is also included in the header of any cecil file (when the + -cecil option is used). + This file is also included in the header file of C++ wrappers (when + using the external "C++" clause). +*/ + +#ifndef _BASE_H +#define _BASE_H + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) /* VC8+ */ +# ifndef _CRT_SECURE_NO_DEPRECATE +# define _CRT_SECURE_NO_DEPRECATE +# endif +# ifndef _CRT_NONSTDC_NO_DEPRECATE +# define _CRT_NONSTDC_NO_DEPRECATE +# endif +#endif /* VC8+ */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined __USE_POSIX || defined __unix__ || defined _POSIX_C_SOURCE +# include +#endif +#if !defined(WIN32) && \ + (defined(WINVER) || defined(_WIN32_WINNT) || defined(_WIN32) || \ + defined(__WIN32__) || defined(__TOS_WIN__) || defined(_MSC_VER)) +# define WIN32 1 +#endif +#ifdef WIN32 +# include +#else +# ifndef O_RDONLY +# include +# endif +# ifndef O_RDONLY +# define O_RDONLY 0000 +# endif +#endif + +#if defined(_MSC_VER) && (_MSC_VER < 1600) /* MSVC older than v10 */ +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed int int32_t; +typedef signed __int64 int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned __int64 uint64_t; +# define PRId8 "d" +# define PRId16 "d" +# define PRId32 "d" +# define PRId64 "I64d" +# define INT8_C(c) c +# define INT16_C(c) c +# define INT32_C(c) c +# define INT64_C(c) c ## i64 +#elif defined(__WATCOMC__) && (__WATCOMC__ <= 1220) /* WATCOM 12.2 or lower */ +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed long int int32_t; +typedef signed __int64 int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned long int uint32_t; +typedef unsigned __int64 uint64_t; +# define PRId8 "d" +# define PRId16 "d" +# define PRId32 "d" +# define PRId64 "Ld" +# define INT8_C(c) c +# define INT16_C(c) c +# define INT32_C(c) c ## L +# define INT64_C(c) c ## i64 +#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x600) /* Borland before 6.0 */ +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed long int int32_t; +typedef signed __int64 int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned long int uint32_t; +typedef unsigned __int64 uint64_t; +# define PRId8 "d" +# define PRId16 "d" +# define PRId32 "ld" +# define PRId64 "I64Ld" +# define INT8_C(c) c +# define INT16_C(c) c +# define INT32_C(c) c ## L +# define INT64_C(c) c ## i64 +#elif defined(__FreeBSD__) && (__FreeBSD__ < 5) /* FreeBSD before 5.0 */ && !defined (_SYS_INTTYPES_H_) +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed long int int32_t; +typedef signed long long int int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned long int uint32_t; +typedef unsigned long long int uint64_t; +#elif defined(__CYGWIN__) && defined(__BIT_TYPES_DEFINED__) /* Cygwin defines intxx_t in sys/types.h instead of inttypes.h */ +# include +# if defined(CYGWIN_VERSION_DLL_MAJOR) && (CYGWIN_VERSION_DLL_MAJOR<1005) +typedef unsigned char uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# endif +#elif defined(SASC) +# error("Too old SAS/C compiler, sorry."); +#elif defined(__SASC__) +# if (__SASC__ < 750 ) /* SAS/C before 7.50 */ +typedef signed char int8_t; +typedef signed short int16_t; +typedef signed long int int32_t; +typedef signed long long int int64_t; +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned long int uint32_t; +typedef unsigned long long int uint64_t; +# endif +#else +# include +# if !defined(INT8_MAX) && defined(INT16_MAX) +/* int8_t is not mandatory */ +typedef int_least8_t int8_t; +# endif +#endif + +#if !defined(PRId16) +# define PRId8 "d" +# define PRId16 "d" +# define PRId32 "ld" +# define PRId64 "lld" +#elif !defined(PRId8) +# define PRId8 "d" +#endif +#if !defined(INT16_C) +# define INT8_C(c) c +# define INT16_C(c) c +# define INT32_C(c) c ## L +# define INT64_C(c) c ## LL +#elif !defined(INT8_C) +# define INT8_C(c) c +#endif +#if !defined(INT16_MIN) +# define INT8_MIN (-INT8_C(127)-1) +# define INT8_MAX (INT8_C(127)) +# define INT16_MIN (-INT16_C(32767)-1) +# define INT16_MAX (INT16_C(32767)) +# define INT32_MIN (-INT32_C(2147483647)-1) +# define INT32_MAX (INT32_C(2147483647)) +# define INT64_MIN (-INT64_C(9223372036854775807)-1) +# define INT64_MAX (INT64_C(9223372036854775807)) +#elif !defined(INT8_MIN) +# define INT8_MIN (-INT8_C(127)-1) +#endif + + +/* + Endian stuff +*/ +#if defined(BSD) && (BSD >= 199103) +# include +#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) +/* bi-endian processor, current mode should be find in machine/endian.h file */ +# include +#elif defined(linux) +# include +#endif + + + +#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER) +# define BYTE_ORDER __BYTE_ORDER +#endif + +#if !defined(LITTLE_ENDIAN) && defined(__LITTLE_ENDIAN) +# define LITTLE_ENDIAN __LITTLE_ENDIAN +#endif + +#if !defined(BIG_ENDIAN) && defined(__BIG_ENDIAN) +# define BIG_ENDIAN __BIG_ENDIAN +#endif + +#if !defined(LITTLE_ENDIAN) +# define LITTLE_ENDIAN 1234 /* LSB first (vax, pc) */ +#endif +#if !defined(BIG_ENDIAN) +# define BIG_ENDIAN 4321 /* MSB first (IBM, net) */ +#endif +#if !defined(PDP_ENDIAN) +# define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long */ +#endif + +#if !defined(BYTE_ORDER) && defined(BIT_ZERO_ON_RIGHT) +# define BYTE_ORDER LITTLE_ENDIAN +#elif !defined(BYTE_ORDER) && defined(BIT_ZERO_ON_LEFT) +# define BYTE_ORDER BIG_ENDIAN +#elif !defined(BYTE_ORDER) + +/* ARM */ +# if defined(__ARMEL__) +# define BYTE_ORDER LITTLE_ENDIAN +# elif defined(__ARMEB__) +# define BYTE_ORDER BIG_ENDIAN +# elif defined(__arm__) +# error "ARMs are bi-endian processors. Endianness is unknown for this system, please drop an e-mail to SmartEiffel@loria.fr" +# endif + +/* HP RISC */ +# if defined(__hppa__) || defined(__hppa) || defined(__hp9000) || \ + defined(__hp9000s300) || defined(hp9000s300) || \ + defined(__hp9000s700) || defined(hp9000s700) || \ + defined(__hp9000s800) || defined(hp9000s800) || defined(hp9000s820) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* IBM */ +# if defined(ibm032) || defined(ibm370) || defined(_IBMR2) || \ + defined(IBM370) || defined(__MVS__) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* Intel x86 */ +# if defined(i386) || defined(__i386__) || defined(__i386) || \ + defined(_M_IX86) || defined(_X86_) || defined(__THW_INTEL) || \ + defined(sun386) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* Intel Itanium */ +# if defined(__ia64__) || defined(_IA64) || defined(__IA64__) || \ + defined(_M_IA64) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* Nationnal Semiconductor 32000 serie */ +# if defined(ns32000) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* Motorola 68000 */ +# if defined(mc68000) || defined(is68k) || defined(macII) || defined(m68k) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* MIPS */ +# if defined(MIPSEL) || defined(_MIPSEL) +# define BYTE_ORDER LITTLE_ENDIAN +# elif defined(MIPSEB) || defined(_MIPSEB) +# define BYTE_ORDER BIG_ENDIAN +# elif defined(__mips__) || defined(__mips) || defined(__MIPS__) +# error "MIPS are bi-endian processors. Endianness is unknown for this system, please drop an e-mail to SmartEiffel@loria.fr" +# endif + +/* Power PC */ +/* this processor is bi-endian, how to know if little-endian is set? */ +# if defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) || \ + defined(__ppc__) || defined(__ppc) || defined(_M_PPC) || \ + defined(__PPC) || defined(__PPC__) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* Pyramid 9810 */ +# if defined(pyr) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* RS/6000 */ +# if defined(__THW_RS6000) || defined(_IBMR2) || defined(_POWER) || \ + defined(_ARCH_PWR) || defined(_ARCH_PWR2) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* SPARC */ +# if defined(__sparc__) || defined(sparc) || defined(__sparc) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* CCI Tahoe */ +# if defined(tahoe) +# define BYTE_ORDER BIG_ENDIAN +# endif + +/* VAX */ +# if defined(vax) || defined(VAX) || defined(__vax__) || defined(_vax_) || \ + defined(__vax) || defined(__VAX) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* ELATE is a virtual OS with a little endian Virtual Processor */ +# if defined(__ELATE__) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* Miscellaneous little endian */ +# if defined(wrltitan) +# define BYTE_ORDER LITTLE_ENDIAN +# endif + +/* Miscellaneous big endian */ +# if defined(apollo) || defined(__convex__) || defined(_CRAY) || defined(sel) +# define BYTE_ORDER BIG_ENDIAN +# endif +#endif + + +#if !defined(BYTE_ORDER) +# error "Unknown byte order. Add your system in above macros once you know your system type. Please drop an e-mail to SmartEiffel@loria.fr" +#endif +#if (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN) +# error "Only little-endian and big-endian are valid at this time. Please drop an e-mail to SmartEiffel@loria.fr" +#endif + + +/* + Byte swapping stuff +*/ +extern void copy_swap_16(const uint16_t *src, uint16_t *dest, int count); + + +/* Because ANSI C EXIT_* are not always defined: */ +#ifndef EXIT_FAILURE +# define EXIT_FAILURE 1 +#endif +#ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +#endif + +/* + On Linux glibc systems, we need to use sig.* versions of jmp_buf, + setjmp and longjmp to preserve the signal handling context. + Currently, the way I figured to detect this is if _SIGSET_H_types has + been defined in /usr/include/setjmp.h. + + NOTE: with gcc, -ansi is used for SmartEiffel generated files EXCEPT in + -no_split mode. ANSI only recognizes the non-sig versions. +*/ +#if (defined(_SIGSET_H_types) && !defined(__STRICT_ANSI__)) +# define JMP_BUF sigjmp_buf +# define SETJMP(x) sigsetjmp( (x), 1) +# define LONGJMP siglongjmp +#else +# define JMP_BUF jmp_buf +# define SETJMP(x) setjmp( (x) ) +# define LONGJMP longjmp +#endif + +/* + Type to store reference objects Id: + */ +typedef int Tid; +typedef struct S0 T0; +struct S0{Tid id;}; + +/* + The default channel used to print runtime error messages: +*/ +#define SE_ERR stderr + +/* + Eiffel type INTEGER_8 is #1: +*/ +typedef int8_t T1; +#define EIF_INTEGER_8 T1 +#define M1 (INT8_C(0)) +#define EIF_INTEGER_8_BITS (CHAR_BIT) +#define EIF_MINIMUM_INTEGER_8 (INT8_MIN) +#define EIF_MAXIMUM_INTEGER_8 (INT8_MAX) + +/* + Eiffel type INTEGER_16 is #10: +*/ +typedef int16_t T10; +#define EIF_INTEGER_16 T10 +#define M10 (INT16_C(0)) +#define EIF_INTEGER_16_BITS (CHAR_BIT*sizeof(T10t)) +#define EIF_MINIMUM_INTEGER_16 (INT16_MIN) /*-32768*/ +#define EIF_MAXIMUM_INTEGER_16 (INT16_MAX) /*+32767*/ + +/* + Eiffel type INTEGER or INTEGER_32 is #2: +*/ +typedef int32_t T2; +#define EIF_INTEGER T2 +#define EIF_INTEGER_32 T2 +#define M2 (INT32_C(0)) +#define EIF_INTEGER_BITS ((T2)(CHAR_BIT*sizeof(T2))) +#define EIF_INTEGER_32_BITS EIF_INTEGER_BITS +#define EIF_MINIMUM_INTEGER (INT32_MIN) +#define EIF_MAXIMUM_INTEGER (INT32_MAX) + +/* + Eiffel type INTEGER_64 is #11: +*/ +typedef int64_t T11; +#define EIF_INTEGER_64 T11 +#define M11 (INT64_C(0)) +#define EIF_INTEGER_64_BITS (CHAR_BIT*sizeof(T11)) +#define EIF_MINIMUM_INTEGER_64 (INT64_MIN) +#define EIF_MAXIMUM_INTEGER_64 (INT64_MAX) + +/* + Eiffel type CHARACTER is #3: +*/ +typedef unsigned char T3; +#define EIF_CHARACTER T3 +#define M3 (0) +#define EIF_CHARACTER_BITS (CHAR_BIT) +#define EIF_MINIMUM_CHARACTER_CODE (0) +#define EIF_MAXIMUM_CHARACTER_CODE (255) +#define T3code(x) ((T10)(x)) +#define T3to_integer(x) ((signed char)(x)) +#define T3to_integer_8(x) ((signed char)(x)) +#define T3to_bit(x) (x) + +/* + Eiffel type REAL_32 is #4: +*/ +typedef float T4; +typedef T4 real32_t; +#define EIF_REAL_32 T4 +#define M4 (0.0) +#define EIF_MINIMUM_REAL_32 (-(FLT_MAX)) +#define EIF_MAXIMUM_REAL_32 (FLT_MAX) + +/* + Eiffel type REAL or REAL_64 is #5: +*/ +typedef double T5; +typedef T5 real64_t; +#define EIF_REAL_64 T5 +#define M5 (0.0) +#define EIF_MINIMUM_REAL_64 (-(DBL_MAX)) +#define EIF_MINIMUM_REAL (EIF_MINIMUM_REAL_64) +#define EIF_MAXIMUM_REAL_64 (DBL_MAX) +#define EIF_MAXIMUM_REAL (EIF_MAXIMUM_REAL_64) + +/* + Eiffel type REAL_EXTENDED is #12: +*/ +typedef long double T12; +typedef T12 real_extended_t; +#define EIF_REAL_EXTENDED T12 +#define M12 (0.0) +#define EIF_MINIMUM_REAL_EXTENDED (-(DBL_MAX)) +#define EIF_MAXIMUM_REAL_EXTENDED (DBL_MAX) + +/* + Eiffel type BOOLEAN is #6: +*/ +typedef char T6; +#define EIF_BOOLEAN T6 +#define M6 (0) +#define EIF_BOOLEAN_BITS (CHAR_BIT) + +/* + Eiffel type POINTER is #8: +*/ +typedef void* T8; +#define EIF_POINTER T8 +/* Sometimes, NULL is defined as 0 */ +#define M8 ((void*)NULL) +#define EIF_POINTER_BITS (CHAR_BIT*sizeof(void*)) + +/* + To use type STRING on the C side: +*/ +#define EIF_STRING T7* + +/* + Some Other EIF_* defined in ETL: +*/ +#define eif_access(x) ((char*)(x)) +#define EIF_REFERENCE T0* +#define EIF_OBJ T0* +#define EIF_OBJECT EIF_OBJ + +/* + Wrappers for `malloc' and `calloc': +*/ +void* se_malloc(size_t size); +void* se_calloc(size_t nmemb, size_t size); +void* se_realloc(void* src, size_t size); + +/* + die method. + */ +void se_die(int code); + +/* + Runtime hooks. They allow different runtime modules to be quite independant. In time, they will also allow + thread-safe operations. + + Currently known modules: + - boost + - no_check + - sedb + - gc + - print stack + - profile + - plugins + + However, currently only profile uses this method. It will be extended to other modules later. + + The currently defined hooks are described in the enum below (the names should be self-explanatory). + */ +typedef enum { + SE_HANDLE_EXCEPTION_SET, /* called when an exception handler is set, prior to SETJMP */ + SE_HANDLE_EXCEPTION_CLEAR, /* called when a feature with an exception handler normally returns */ + SE_HANDLE_EXCEPTION_THROWN, /* called when an exception is thrown, prior to the LONGJMP */ + SE_HANDLE_ENTER_GC, /* called when gc_start() begins */ + SE_HANDLE_EXIT_GC, /* called when gc_start() ends */ + SE_HANDLE_ENTER_PRINT_STACK, /* called when se_print_run_time_stack() begins */ + SE_HANDLE_EXIT_PRINT_STACK, /* called when se_print_run_time_stack() ends */ + SE_HANDLE_NO_MORE_MEMORY, /* called by se_alloc() and co */ + SE_HANDLE_SEDB_BREAK, /* called when sedb stops the program */ + SE_HANDLE_SEDB_CONTINUE, /* called when sedb continues the program */ + SE_HANDLE_RUNTIME_ERROR, /* called when a runtime error is raised and not caught by an exception. Cannot be raised in boost mode. */ + SE_HANDLE_DIE_WITH_CODE, /* called when the program is stopped by the die_with_code feature. The data points to the int code. */ + SE_HANDLE_NORMAL_EXIT /* called when the program correctly terminates. The data is null. */ +} se_handler_action_t; + +extern int handlers_count; +typedef void se_runtime_handler_t(se_handler_action_t action, void*data); +void register_handler(se_runtime_handler_t*handler); +void _handle(se_handler_action_t action, void*data); + +#define handle(action,data) do{if(handlers_count>0)_handle(action,data);}while(0) + +#endif /* #ifndef _BASE_H */ +#define SE_BOOST 1 +#define SE_GC_LIB 1 +/* C Header Pass 1: */ +typedef union _se_agent se_agent; +typedef struct _se_agent0 se_agent0; +typedef struct S110 T110; +typedef struct S120 T120; +typedef struct S189 T189; +typedef T0 T202; +typedef struct S246 T246; +typedef struct S176 T176; +typedef struct S128 T128; +typedef struct S286 T286; +typedef struct S277 T277; +typedef struct S271 T271; +typedef struct S268 T268; +typedef struct S266 T266; +typedef struct S265 T265; +typedef struct S264 T264; +typedef struct S139 T139; +typedef struct S142 T142; +typedef struct S141 T141; +typedef struct S258 T258; +typedef struct S256 T256; +typedef struct S216 T216; +typedef struct S254 T254; +typedef struct S253 T253; +typedef struct S252 T252; +typedef struct S249 T249; +typedef struct S245 T245; +typedef struct S244 T244; +typedef struct S243 T243; +typedef struct S146 T146; +typedef struct S148 T148; +typedef struct S147 T147; +typedef struct S236 T236; +typedef struct S235 T235; +typedef struct S234 T234; +typedef struct S232 T232; +typedef struct S230 T230; +typedef struct S228 T228; +typedef struct S227 T227; +typedef struct S226 T226; +typedef struct S225 T225; +typedef struct S158 T158; +typedef struct S54 T54; +typedef struct S223 T223; +typedef struct S222 T222; +typedef struct S221 T221; +typedef struct S67 T67; +typedef struct S7 T7; +typedef struct S218 T218; +typedef struct S217 T217; +typedef struct S215 T215; +typedef struct S214 T214; +typedef struct S213 T213; +typedef struct S211 T211; +typedef struct S208 T208; +typedef struct S207 T207; +typedef struct S206 T206; +typedef struct S131 T131; +typedef struct S130 T130; +typedef struct S72 T72; +typedef struct S53 T53; +typedef void*T46; +typedef struct S175 T175; +typedef struct S205 T205; +typedef int T143; +typedef struct S204 T204; +typedef struct S43 T43; +typedef struct S69 T69; +typedef struct S70 T70; +typedef struct S64 T64; +typedef struct S25 T25; +/* C Header Pass 2: */ +typedef T0**T293; +#define M293 NULL +typedef T0**T292; +#define M292 NULL +typedef T0**T291; +#define M291 NULL +typedef T0**T290; +#define M290 NULL +typedef T0**T289; +#define M289 NULL +typedef T0**T288; +#define M288 NULL +typedef T0**T287; +#define M287 NULL +typedef T0**T284; +#define M284 NULL +typedef T0**T281; +#define M281 NULL +typedef T0**T276; +#define M276 NULL +typedef T0**T270; +#define M270 NULL +typedef T0**T267; +#define M267 NULL +typedef T0**T263; +#define M263 NULL +typedef T0**T262; +#define M262 NULL +typedef T0**T261; +#define M261 NULL +typedef T0**T260; +#define M260 NULL +typedef T0**T259; +#define M259 NULL +typedef T0**T257; +#define M257 NULL +typedef T0**T255; +#define M255 NULL +typedef T0**T251; +#define M251 NULL +typedef T2*T250; +#define M250 NULL +typedef T0**T247; +#define M247 NULL +typedef T0**T239; +#define M239 NULL +typedef T0**T238; +#define M238 NULL +typedef T0**T237; +#define M237 NULL +typedef T0**T220; +#define M220 NULL +typedef T0**T219; +#define M219 NULL +typedef T8*T212; +#define M212 NULL +typedef T3*T9; +#define M9 NULL +/* C Header Pass 3: */ +struct S189{T11 _time_memory;}; +int se_cmpT189(T189 o1,T189 o2); +struct S176{T189 _time;T2 _microsecond;}; +int se_cmpT176(T176 o1,T176 o2); +/* C Header Pass 4: */ +struct S110{Tid id;T0* _stream;}; +extern T110 M110; +struct S120{Tid id;T0* _input_stream;}; +extern T120 M120; +extern T189 M189; +extern T176 M176; +struct S286{Tid id;T0* _item;}; +extern T286 M286; +struct S277{Tid id;T0* _item;}; +extern T277 M277; +struct S271{Tid id;T0* _item;}; +extern T271 M271; +struct S268{Tid id;T0* _item;}; +extern T268 M268; +struct S266{T0* _item;T8 _key;T0* _next;}; +extern T266 M266; +struct S265{Tid id;T0* _item;}; +extern T265 M265; +struct S264{T0* _item;T2 _key;T0* _next;}; +extern T264 M264; +struct S258{Tid id;T0* _item;}; +extern T258 M258; +struct S256{T0* _item;T0* _key;T0* _next;}; +extern T256 M256; +struct S254{T290 _storage;T2 _capacity;T2 _upper;}; +extern T254 M254; +struct S253{Tid id;T0* _item;}; +extern T253 M253; +struct S252{T2 _item;T2 _key;T0* _next;}; +extern T252 M252; +struct S249{Tid id;T0* _item;}; +extern T249 M249; +struct S246{T0* _item;T0* _key;T0* _next;}; +extern T246 M246; +struct S245{Tid id;T0* _item;}; +extern T245 M245; +struct S244{T289 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T244 M244; +struct S243{Tid id;T0* _item;}; +extern T243 M243; +struct S147{T6 _queryable;T2 _timeout;T176 _expiration;T6 _expiration_valid;T6 _current_time_valid;T8 _read_set;T2 _read_size;T8 _write_set;T2 _write_size;T8 _exception_set;T2 _exception_size;T2 _highest;}; +extern T147 M147; +struct S236{T288 _storage;T2 _capacity;T2 _upper;}; +extern T236 M236; +struct S235{T287 _storage;T2 _capacity;T2 _upper;}; +extern T235 M235; +struct S234{T284 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T234 M234; +struct S232{T281 _storage;T2 _capacity;T2 _upper;}; +extern T232 M232; +struct S230{T276 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T230 M230; +struct S228{T270 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T228 M228; +struct S227{T267 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T227 M227; +struct S226{T263 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T226 M226; +struct S225{T262 _storage;T2 _capacity;T2 _upper;}; +extern T225 M225; +struct S158{T0* _container;}; +extern T158 M158; +struct S54{T0* _filter;T9 _buffer;T2 _capacity;}; +extern T54 M54; +struct S139{T2 _key_count;T2 _minimum_code;T2 _maximum_code;}; +extern T139 M139; +struct S223{T261 _storage;T2 _capacity;T2 _upper;}; +extern T223 M223; +struct S142{T2 _buttons_count;}; +extern T142 M142; +struct S222{T260 _storage;T2 _capacity;T2 _upper;}; +extern T222 M222; +struct S141{T6 _absolute;T2 _motion_buffer_size;T0* _minimums;T0* _maximums;T0* _resolutions;}; +extern T141 M141; +struct S221{T259 _storage;T2 _capacity;T2 _upper;}; +extern T221 M221; +struct S218{T257 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T218 M218; +struct S217{T255 _storage;T2 _capacity;T2 _upper;}; +extern T217 M217; +struct S216{T0* _callbacks;T2 _last;T2 _index;}; +extern T216 M216; +struct S215{T251 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T215 M215; +struct S214{T250 _storage;T2 _capacity;T2 _upper;}; +extern T214 M214; +struct S213{T250 _storage;T2 _capacity;T2 _upper;T2 _lower;T2 _storage_lower;}; +extern T213 M213; +struct S211{T247 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T211 M211; +struct S208{T239 _buckets;T2 _capacity;T2 _count;T2 _cache_user;T0* _free_nodes;}; +extern T208 M208; +struct S146{Tid id;T0* _stream_exception;T0* _can_read;T6 _is_connected;T2 _filtered_descriptor;T8 _delete_function;T8 _read_function;T8 _data;}; +extern T146 M146; +struct S207{T238 _storage;T2 _capacity;T2 _upper;}; +extern T207 M207; +struct S206{T237 _storage;T2 _capacity;T2 _upper;}; +extern T206 M206; +struct S148{T0* _job_list;T0* _finished_jobs;T0* _ready_jobs;T0* _events;T6 _pause;T6 _break;}; +extern T148 M148; +struct S131{Tid id;T0* _can_read;T2 _descriptor;}; +extern T131 M131; +struct S130{T0* _loop_stack;T6 _stop;T0* _vision;T0* _event_catcher_stack;}; +extern T130 M130; +struct S128{Tid id;T2 _priority;T6 _done;T2 _current_event_type;T0* _widget;T0* _event;T0* _pointer_move_event;T0* _geometry_change_event;T0* _extension_devices;T0* _graphic_connection;T6 _suspend;T0* _event_catcher_found;}; +extern T128 M128; +struct S72{T8 _widget;T2 _pos_y;T2 _pos_x;T0* _layout;T2 _width;T2 _height;T2 _min_height;T2 _min_width;T2 _std_width;T2 _std_height;T0* _child;}; +extern T72 M72; +struct S53{T0* _filter;T2 _buffer_position;T9 _buffer;T2 _capacity;}; +extern T53 M53; +extern T46 M46; +struct S175{T0* _devices;}; +extern T175 M175; +struct S205{T220 _storage;T2 _capacity;T2 _upper;}; +extern T205 M205; +extern T143 M143; +struct S204{T219 _storage;T2 _capacity;T2 _upper;}; +extern T204 M204; +struct S67{T2 _device_id;T0* _name;T0* _type;T6 _is_current_pointer;T6 _is_current_keyboard;T6 _is_available_extension;T0* _key_capabilities;T0* _button_capabilities;T0* _axes_capabilities;T8 _x_device;T0* _actions;T0* _events_indexes;T0* _events_id;T8 _events_classes;}; +extern T67 M67; +struct S43{T0* _filter;}; +extern T43 M43; +struct S69{T0* _xinput_ivy;T2 _y_offset;T2 _x_offset;T5 _prediction_time;T2 _ignored_counter;T2 _ignore_rate;T0* _button_message_header;T0* _pointer_message_header;T2 _old_presure;T0* _y_history;T0* _x_history;T0* _time_history;T2 _predicted_y;T2 _predicted_x;T5 _a2y;T5 _a2x;T5 _t0;T5 _y2;T5 _x2;T5 _s2y;T5 _s2x;T5 _s2yn;T5 _s2xn;T5 _t1;T5 _t2;}; +extern T69 M69; +struct S7{T9 _storage;T2 _count;T2 _capacity;}; +extern T7 M7; +struct S70{Tid id;T2 _priority;T6 _started;T0* _pattern_list;T0* _callback_list;T2 _destination_count;T0* _tmp_client_list;T6 _done;T0* _events_set;T0* _ivy_clients;T0* _application_name_;T0* _ready_message_;}; +extern T70 M70; +struct S64{T2 _display_width;T2 _display_height;T0* _loop_stack;T0* _event_catcher;T0* _graphic_connection;T0* _widget;}; +extern T64 M64; +struct S25{T0* _ivy_bus;T0* _application_name;T0* _device_id;T0* _screen;int _x11;T2 _left_pad_position;T2 _right_pad_position;T0* _ivy;}; +extern T25 M25; +extern char*s25_0; +extern char*s25_21190322; +extern char*s25_314746909; +extern char*s69_190991; +extern char*s69_475; +extern char*s13_1432888418; +extern char*s69_697; +extern char*s69_1961093439; +extern char*s69_104371129; +extern char*s25_44143; +extern char*s69_104371267; +extern char*s69_1699147265; +extern char*s13_1210; +extern char*s69_1756148648; +extern char*s69_1756148653; +extern char*s25_1948078333; +extern char*s69_1461; +extern char*s69_1466; +extern char*s69_23436791; +extern char*s25_1666922512; +extern char*s69_56246305; +extern char*s25_1957581; +extern char*s25_1403610646; +extern char*s69_4725661; +extern char*s69_4725666; +extern char*s69_4738061; +extern char*s25_1213754110; +extern char*s25_765567725; +extern char*s69_2179769; +extern char*s25_751291742; +extern char*s25_1554692325; +extern char*s25_357338863; +extern char*s69_2676; +extern char*s69_1874520032; +extern char*s69_1619665677; +extern char*s25_1491411490; +extern char*s25_4487261; +extern char*s69_1940108584; +extern char*s25_694149733; +extern char*s64_1686724329; +extern char*s69_586741066; +extern char*s25_703548632; +extern char*s25_89639; +extern char*s69_15980; +extern char*s69_397440; +extern char*s25_69208946; +extern char*s69_188916; +extern char*s25_447643634; +extern char*s69_2057747851; +extern char*s25_3479972; +extern char*s25_557679246; +extern char*s25_1638797568; +extern char*s25_1260406502; +extern char*s69_22702411; +extern char*s69_22702416; +extern char*s25_946366; +extern char*s69_1501987274; +extern char*s25_382517595; +extern char*s69_952626; +extern char*s69_2112369621; +extern char*s69_10739017; +extern char*s69_10739024; +extern char*s69_10739030; +extern char*s70_202554; +extern char*s143_1472358418; +extern char*s25_1959886733; +extern char*s69_1257860908; +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#define SE_BOOST 1 +void se_print_run_time_stack (void); +void se_signal_handler(int sig); +#define FSOC_SIZE 8192 +#define RSOC_SIZE 32768 +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +/* + This file (SmartEiffel/sys/runtime/gc_lib.h) is automatically included + when the Garbage Collector is used (default, unless option -no_gc has + been selected). +*/ + +#define SE_GC_LIB 1 + +#define SE_GC_LOW_MEMORY_STRATEGY 0 +#define SE_GC_HIGH_MEMORY_STRATEGY 1 +#define SE_GC_DEFAULT_MEMORY_STRATEGY 2 +extern int se_gc_strategy; + + +#define RSOH_UNMARKED 15253 +#define RSOH_FREE 1 +#define RSOH_MARKED 2 + + +#define FSOH_UNMARKED ((void *) 1) +#define FSOH_MARKED ((void *) 2) + +/* To codify the state and the type of some Memory Chunk, we are + using the following definitions : +*/ +#define FSO_FREE_CHUNK (-2) +#define RSO_FREE_CHUNK (-1) +#define RSO_USED_CHUNK ( 0) +#define FSO_STORE_CHUNK ( 1) +#define FSO_USED_CHUNK ( 2) +#define FREE_CHUNK(x) ((x)<0) + +/* Minimum size for a store area in a ReSizable Objects Chunk : + */ +#define RSOC_MIN_STORE 512 + +/* The default channel used to print -gc_info flag information : +*/ +#define SE_GCINFO SE_ERR + +extern int collector_counter; /* MEMORY.collector_counter */ + +typedef struct s_mch mch; /* Memory Chunk Header. */ +typedef struct s_fsoc fsoc; /* Fixed Size Objects Chunk. */ +typedef union u_rsoh rsoh; /* ReSizable Object Header. */ +typedef struct s_fll_rsoh fll_rsoh; +typedef struct s_rsoc rsoc; /* ReSizable Objects Chunk. */ +typedef struct s_na_env na_env; /* Native Array ENVironment. */ + + +struct s_mch{ + unsigned int size; /* In number of bytes (actual argument of malloc).*/ + int state_type; /* One value in : RSO_USED_CHUNK, + FREE_CHUNK, FSO_STORE_CHUNK, FSO_USED_CHUNK */ + void(*amfp)(mch*,void*); /* Align Mark Function Pointer. */ + void(*swfp)(mch*); /* SWeep Function Pointer. */ +}; + +struct s_fsoc{ + mch header; /* Common header for fsoc and rsoc. */ + fsoc* next; /* The next one when in free list (fsocfl). */ + int count_minus_one; + double first_object; +}; + +typedef struct _rso_header rso_header; + +struct _rso_header{ + unsigned int size; + int magic_flag; /* RSOH_MARKED when used, + RSOH_FREE when free, + else RSOH_UNMARKED */ +}; + +typedef union u_fso_header fso_header; + +union u_fso_header{ + void* flag; + void* next;/* accurately typed as gcXX* in actual fso headers */ +}; + +union u_rsoh{ + rso_header header; + double padding; +}; + +struct s_fll_rsoh { + rso_header rsoh_field; + fll_rsoh* nextflol; +}; + +struct s_rsoc{ + mch header; /* Common header for fsoc and rsoc. */ + unsigned int isize; /* Initial size (at malloc time) to detect split chunks. */ + rsoc* next; /* Next one when in free list (rsocfl) or in na_env->chunk_list. */ + fll_rsoh*free_list_of_large; /* Intra. free list. */ + na_env*nae; + rsoh first_header; +}; + +struct s_na_env{ + unsigned int store_left; + rsoh* store; + rsoc*store_chunk; + rsoc*chunk_list; /*List of chunks of that type that have a non-null free_list_of_large*/ + void (*gc_mark)(T0*); + int space_used; +}; + +extern void**stack_bottom; +extern mch**gcmt; +extern int gcmt_max; +extern int gcmt_used; +extern int gc_is_off; +extern fsoc* fsocfl; +extern unsigned int fsoc_count; +extern unsigned int rsoc_count; +extern void*gcmt_tail_addr; + +void gc_sweep(void); +void gc_mark(void* p); +mch* gc_find_chunk(void* p); +int gc_stack_size(void); +int garbage_delayed(void); +void gc_update_ceils(void); +char*new_na(na_env*nae,unsigned int size); +unsigned int fsocfl_count(void); +unsigned int rsocfl_count(void); +void gc_dispose_before_exit(void); +void mark_stack_and_registers (void); +fsoc* gc_fsoc_get1(void); +fsoc* gc_fsoc_get2(void); + +int gc_memory_used(void); +/*The generic se_agent0 definition:*/ +struct _se_agent0{ +Tid id; +Tid creation_mold_id; +void(*afp)(se_agent*);void(*gc_mark_agent_mold)(se_agent*); +int(*eq)(se_agent*,se_agent*); +}; +#include "X11/extensions/XInput.h" + +#define x_list_input_devices(list_size) (XListInputDevices(dpy, list_size)) +// XDeviceInfo * XListInputDevices(Display * display, int * returned_list_size); + + +#define x_device_info_id(device_list, index) (((XDeviceInfo *)device_list)[index].id) +//XID x_device_info_id(XDeviceInfo * device_list, int index) + +#define x_device_info_type(device_list, index) (((XDeviceInfo *)device_list)[index].type) +//Atom x_device_info_type(XDeviceInfo * device_list, int index) + +#define x_device_info_name(device_list, index) (((XDeviceInfo *)device_list)[index].name) +//char * x_device_info_name(XDeviceInfo * device_list, int index) + +#define x_device_info_num_classes(device_list, index) (((XDeviceInfo *)device_list)[index].num_classes) +//int x_device_info_num_classes(XDeviceInfo * device_list, int index) + +#define x_device_info_class_info(device_list, index) (((XDeviceInfo *)device_list)[index].inputclassinfo) +//XAnyClassPtr x_device_info_class_info(XDeviceInfo * device_list, int index) + +#define x_next_class_info(class_info) ((XAnyClassPtr)((char *)class_info + ((XAnyClassPtr)class_info)->length)) +//XAnyClassPtr x_next_class_info(XAnyClassPtr class_info) + +#define x_is_key_class_info(class_info) (((XAnyClassPtr)class_info)->class == KeyClass) +//bool x_is_key_class_info(XAnyClassPtr class_info) + +#define x_is_button_class_info(class_info) (((XAnyClassPtr)class_info)->class == ButtonClass) +//bool x_is_button_class_info(XAnyClassPtr class_info) + +#define x_is_valuator_class_info(class_info) (((XAnyClassPtr)class_info)->class == ValuatorClass) +//bool x_is_valuator_class_info(XAnyClassPtr class_info) + +#define x_device_info_is_pointer(device_list, index) (((XDeviceInfo *)device_list)[index].use == IsXPointer) +//bool x_device_info_is_pointer(XDeviceInfo * device_list, int index) + +#define x_device_info_is_keyboard(device_list, index) (((XDeviceInfo *)device_list)[index].use == IsXKeyboard) +//bool x_device_info_is_keyboard(XDeviceInfo * device_list, int index) + +#define x_device_info_is_available_extension(device_list, index) (((XDeviceInfo *)device_list)[index].use == IsXExtensionDevice) +//bool x_device_info_is_available_extension(XDeviceInfo * device_list, int index) + +#define x_button_info_num_buttons(info) (((XButtonInfo *)info)->num_buttons) +//short x_button_info_num_buttons(XButtonInfo * info) + +#define x_valuator_info_minimum(info, index) (((XValuatorInfo *)info)->axes[index].min_value) +//int x_valuator_info_minimum(XValuatorInfo * info, int index) + +#define x_valuator_info_maximum(info, index) (((XValuatorInfo *)info)->axes[index].max_value) +//int x_valuator_info_maximum(XValuatorInfo * info, int index) + +#define x_valuator_info_resolution(info, index) (((XValuatorInfo *)info)->axes[index].resolution) +//int x_valuator_info_resolution(XValuatorInfo * info, int index) + +#define x_open_device(device_id) XOpenDevice(dpy, device_id) +//XDevice * x_open_device(XID device_id) + +#define x_close_device(device) XCloseDevice(dpy, device) +//void x_close_device(XDevice * device) + +#define x_device_motion_event_data(index) (((XDeviceMotionEvent*)&last_event)->axis_data[index]) +//int x_device_motion_event_data(int index) + +#define x_device_proximity_event_data(index) (((XProximityNotifyEvent*)&last_event)->axis_data[index]) +//int x_device_proximity_event_data(int index) + +#define x_device_button_event_number (((XDeviceButtonEvent*)&last_event)->button) +//int x_device_button_event_number + +#define x_device_event_time (((XDeviceButtonEvent*)&last_event)->time) +//int x_device_event_time + +extern void x_key_info_init(XKeyInfo *info, int *min_k, int *max_k, int *num_k); + +extern void x_valuator_info_init(XValuatorInfo *info, int *nb_axes, int *is_absolute, int *buf_size); + +extern void * x_device_init_events(XDevice * device, int * events_id); +// Result is XEventClass * + +void x_device_select_events(void * window, XEventClass * events_classes); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +# include +# include /* needed for timeGetTime() */ +void vision_init(void); +# ifndef WM_MOUSEWHEEL +# define WM_MOUSEWHEEL 0x20A +# endif +#else +# include +# include +# include +#endif + +#ifndef VISION_DEBUG +# define vision_check_call(x) (x) +# define vision_check(x) +#else + +/* Executes x; if it returns zero, exits. */ +#define vision_check_call(x) \ + do { \ + if (!(x)) { \ + fprintf(stderr, "Call failed line %d in %s (call was: \"%s\")\n", __LINE__, __FILE__, #x); exit(1); \ + } \ + } while (0) + +/* If x is non-zero, exits. */ +#define vision_check(x) \ + do { \ + if (!(x)) { \ + fprintf(stderr, "Check failed line %d in %s (test was: \"%s\")\n", __LINE__, __FILE__, #x); exit(1); \ + } \ + } while (0) + +#endif + + +#define basic_vision_init _basic_vision_init() +#define basic_vision_next_event _basic_vision_next_event() +#define basic_vision_character _basic_vision_character() +#define basic_vision_key _basic_vision_key() +extern int _basic_vision_init(void); +extern int _basic_vision_next_event(void); +extern int _basic_vision_character(void); +extern int basic_vision_get_keysym(char*); +extern void *basic_vision_get_color(int *r, int *g, int *b); + +#ifdef WIN32 + extern HDC hdc; + extern const char *CLASSNAME; + extern HINSTANCE main_hInstance; + extern int main_nCmdShow; + extern MSG last_message; + extern HANDLE sem_thread_finished_work; + extern HANDLE sem_new_window; + extern void display_error(int num); + enum commands {CREATE_WINDOW = 1, SET_TITLE, CLEAR_AREA, MAP_WINDOW, MOVE_WINDOW, SET_FOCUS}; + struct cmd_list {struct cmd_list * next; enum commands cmd_type; int param1; int param2; int param3; int param4; int param5; int param6;}; + extern volatile struct cmd_list *first_cmd; + extern volatile struct cmd_list *first_free_cmd; + extern HANDLE sem_cmd_ready; + + /* paint message informations */ + extern PAINTSTRUCT paintstruct; + + extern RECT windowRect; /* new window size definition */ + extern DWORD message_thread_id; + extern int decorated_window_x_offset; + extern int decorated_window_y_offset; + extern int decorated_window_width_offset; + extern int decorated_window_height_offset; + +# define basic_vision_real_event (last_message.message) +# define basic_vision_flush ((void)0) +# define basic_vision_display_width (GetSystemMetrics(SM_CXSCREEN)) +# define basic_vision_display_height (GetSystemMetrics(SM_CYSCREEN)) +# define basic_vision_event_widget ((void *)(last_message.hwnd)) +# define basic_vision_pointer_x ((short)LOWORD(last_message.lParam)) +# define basic_vision_pointer_y ((short)HIWORD(last_message.lParam)) +# define basic_vision_pointer_x_root (last_message.pt.x) +# define basic_vision_pointer_y_root (last_message.pt.y) +# define basic_vision_event_time (last_message.time) +# define basic_vision_expose_x (paintstruct.rcPaint.left) +# define basic_vision_expose_y (paintstruct.rcPaint.top) +# define basic_vision_expose_width (paintstruct.rcPaint.right-paintstruct.rcPaint.left) +# define basic_vision_expose_height (paintstruct.rcPaint.bottom-paintstruct.rcPaint.top) +# define basic_vision_geometry_x (windowRect.left) +# define basic_vision_geometry_y (windowRect.top) +# define basic_vision_geometry_width (windowRect.right) +# define basic_vision_geometry_height (windowRect.bottom) +# define basic_vision_geometry_border (GetSystemMetrics(SM_CXBORDER)) /* --TODO: X and Y may have different values */ +# define basic_vision_is_left_down (GetAsyncKeyState(button_swapped?VK_RBUTTON:VK_LBUTTON)>>15) +# define basic_vision_is_middle_down (GetAsyncKeyState(VK_MBUTTON)>>15) +# define basic_vision_is_right_down (GetAsyncKeyState(button_swapped?VK_LBUTTON:VK_RBUTTON)>>15) + +# define basic_vision_extension_device_id (fprintf(stderr, "No extension currently available for Windows.\n")) + +extern int button_swapped; + +#else + extern Display *dpy; /* X server connection */ + extern XEvent last_event; + + extern Atom atom_DELWIN; + extern Atom atom_PROTOCOLS; + +# define basic_vision_real_event (last_event.type) +# define basic_vision_flush XFlush(dpy) +# define basic_vision_display_width (DisplayWidth(dpy,DefaultScreen(dpy))) +# define basic_vision_display_height (DisplayHeight(dpy,DefaultScreen(dpy))) +# define basic_vision_event_widget ((void *)(last_event.xany.window)) +# define basic_vision_pointer_x (((XButtonEvent*)&last_event)->x) +# define basic_vision_pointer_y (((XButtonEvent*)&last_event)->y) +# define basic_vision_pointer_x_root (((XButtonEvent*)&last_event)->x_root) +# define basic_vision_pointer_y_root (((XButtonEvent*)&last_event)->y_root) +# define basic_vision_event_time (((XButtonEvent*)&last_event)->time) +# define basic_vision_expose_x (((XExposeEvent*)&last_event)->x) +# define basic_vision_expose_y (((XExposeEvent*)&last_event)->y) +# define basic_vision_expose_width (((XExposeEvent*)&last_event)->width) +# define basic_vision_expose_height (((XExposeEvent*)&last_event)->height) +# define basic_vision_geometry_x (((XConfigureEvent*)&last_event)->x) +# define basic_vision_geometry_y (((XConfigureEvent*)&last_event)->y) +# define basic_vision_geometry_width (((XConfigureEvent*)&last_event)->width) +# define basic_vision_geometry_height (((XConfigureEvent*)&last_event)->height) +# define basic_vision_geometry_border (((XConfigureEvent*)&last_event)->border_width) +# define basic_vision_is_left_down ((((XCrossingEvent*)&last_event)->state & Button1Mask) != 0 ) +# define basic_vision_is_middle_down ((((XCrossingEvent*)&last_event)->state & Button2Mask) != 0 ) +# define basic_vision_is_right_down ((((XCrossingEvent*)&last_event)->state & Button3Mask) != 0 ) + +/* For X Input extension */ +# define basic_vision_extension_device_id (((XMotionEvent*)&last_event)->root) /* TRICK (should be deviceid of Device Events */ + +#endif + +int vision_available(void); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#include + +#define text_file_read_open(p) (fopen(((char*)(p)),"r")) +#define text_file_write_open(p) (fopen(((char*)(p)),"w")) +#define text_file_write_append(p) (fopen(((char*)(p)),"a")) +#define text_file_read_write_open(p) (fopen(((char*)(p)),"r+")) +#define text_file_read_write_append(p) (fopen(((char*)(p)),"a+")) +#define binary_file_read_open(p) (fopen(((char*)(p)),"rb")) +#define binary_file_write_open(p) (fopen(((char*)(p)),"wb")) +#define binary_file_write_append(p) (fopen(((char*)(p)),"ab")) +#define io_fclose(p) (fclose((FILE*)(p))) +#define io_flush(p) (fflush((FILE*)(p))) +#define io_getc(f) (getc(((FILE*)(f)))) +#define io_putc(b, f) (putc((b),((FILE*)(f)))) +#define io_ungetc(b, f) (ungetc((b), (FILE*)(f))) +#define io_fread(b, n, f) (fread((void *)(b),(size_t)(1), (size_t)(n),(FILE*)(f))) +#define io_fwrite(b, n, f) (fwrite((void *)(b),(size_t)(1), (size_t)(n),(FILE*)(f))) +#define io_feof(f) (feof(((FILE*)(f)))) +#define io_rename(o, n) (rename(((char*)(o)),((char*)(n)))) +#define io_remove(f) (remove(((char*)(f)))) +#define io_fseek(f, o) (fseek((FILE*)(f),(o),SEEK_SET)) +#define io_ftell(f) ((EIF_INTEGER_64)ftell((FILE*)(f))) + +#if defined __USE_POSIX || defined __unix__ || defined _POSIX_C_SOURCE +# define read_stdin(b, s) (read(STDIN_FILENO, b, s)) +#else + extern int read_stdin(EIF_CHARACTER *buffer, int size); +#endif + +extern void io_copy(char*source, char*target); +extern int io_file_exists(char*source); +extern int io_same_physical_file(char*path1,char*path2); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#include + +#define basic_time ((EIF_INTEGER_64)time(NULL)) +EIF_REAL_64 time_difftime(time_t t2, time_t t1); +EIF_INTEGER time_getyear(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getmonth(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getday(time_t t, EIF_INTEGER m); +EIF_INTEGER time_gethour(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getminute(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getsecond(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getyday(time_t t, EIF_INTEGER m); +EIF_INTEGER time_getwday(time_t t, EIF_INTEGER m); +EIF_BOOLEAN time_is_summer_time_used(time_t t); +EIF_INTEGER_64 time_mktime(EIF_INTEGER year, EIF_INTEGER mon, + EIF_INTEGER mday, EIF_INTEGER hour, + EIF_INTEGER min, EIF_INTEGER sec); +void time_add_second(EIF_INTEGER_64 *t, EIF_INTEGER s); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#define sprintf_pointer(buffer, pointer) sprintf((char*)(buffer),"%p",pointer) +void sprintf_real_64(EIF_CHARACTER* b, EIF_CHARACTER m, int32_t f, real64_t r); +void sprintf_real_extended(EIF_CHARACTER* b, EIF_CHARACTER m, int32_t f, real_extended_t r); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#define pointer_hash_code(p) (((unsigned int)(unsigned long)(p))>>1) +#define pointer_to_any(p) ((T0*)(p)) +#define pointer_plus(p, o) (((char*)(p))+o) + +#define x_get_atom_name(atom) XGetAtomName(dpy, (Atom)atom) + +extern int x_query_extension(char * extension_name); + +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +/*# include done in base.h */ +# ifndef _MSC_VER +# include +# endif + extern int win32_msg; + extern int win32_msg_ready; + extern HANDLE sem_msg_ready; +#else +# include +/*# include done in base.h */ +/*# include done in base.h */ +#endif + +#ifdef WIN32 +# define sequencer_watch(set, fd) do { \ + if ((fd)==-1) win32_msg=1; else FD_SET((SOCKET)fd, (fd_set*)(set)); \ +} while(0) +#else +# define sequencer_watch(set, fd) FD_SET(fd, (fd_set*)(set)) +#endif + + +#ifdef WIN32 +/****TODO: fd evaluated twice. */ +# define sequencer_is_ready(set, fd) (EIF_BOOLEAN)(((fd)==-1)?win32_msg_ready:FD_ISSET(fd, (fd_set*)(set))) +#else +# define sequencer_is_ready(set, fd) FD_ISSET(fd, (fd_set*)(set)) +#endif + + +#ifdef WIN32 +# define sequencer_reset(set) do{win32_msg=0;win32_msg_ready=FALSE;FD_ZERO((fd_set*)(set));}while(0) +#else +# define sequencer_reset(set) FD_ZERO((fd_set*)(set)) +#endif + +#define sequencer_create_set (_sequencer_create_set()) +EIF_POINTER _sequencer_create_set(void); +int sequencer_wait(int n, fd_set *read_set, int read_size, fd_set *write_set, int write_size, fd_set *exception_set, int exception_size, int s, int us); + +#define sequencer_descriptor(file) (fileno((FILE *)(file))) +#include "Ivy/ivy.h" +#include "Ivy/ivyloop.h" +#include "Ivy/ivysocket.h" + +extern void ivy_init(char * application_name, char * ready_text, void * eiffel_object, void * channel_up_callback, void * channel_down_callback, void * agent_call_callback); + +extern void * bind_message(char * pattern, void * agent); + +#define send_message(txt) IvySendMsg("%s", txt) +#define IvyIdle IvyIdle() +#define read_callback(read_func, channel, descriptor, data) ((void (*)(void *, int, void *))read_func)(channel, descriptor, data) +#define delete_callback(delete_func, data) ((void (*)(void *))delete_func)(data) +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifndef WIN32 +# include +#endif + +extern EIF_INTEGER basic_microsecond_microsecond; +extern EIF_INTEGER_64 basic_microsecond_time; +#define basic_microsecond_update (_basic_microsecond_update()) +void _basic_microsecond_update(void); +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#ifdef WIN32 +extern void new_window(void); + +typedef struct window_description_s window_description; +struct window_description_s { + HWND Current; + HBRUSH background; + HBITMAP background_pixmap; /* if non-void, use this pixmap for background + painting. Useful for Win95 only */ + struct window_description_s *parent; + int marked; + int min_width; + int max_width; + int min_height; + int max_height; + int decorated; +}; + +extern window_description screen_desc; + +# define basic_window_root_id NULL +#else +# define basic_window_root_id ((void*)DefaultRootWindow(dpy)) +#endif + + +extern void * basic_window_create(int x, int y, int width, int height, void * parent, int decorate); + +extern void * basic_window_get_drawing_widget(void *window); + +extern char* basic_window_get_title(void *window); + +extern void basic_window_free_title(void *title); + +extern void basic_window_set_title(void *window, void *title); + +extern void basic_window_set_bg_color(void *window, void *color); + +extern void basic_window_set_bg_pixmap(void *window, void *pixmap); + +extern void basic_window_clear_no_expose(void *window); + +extern void basic_window_clear_area_no_expose(void *window, int x, int y, int w, int h); + +extern void basic_window_clear_area(void *window, int x, int y, int w, int h); + +extern void basic_window_set_kbd_focus(void *window); + +extern void basic_window_map(void *window); + +extern void basic_window_unmap(void *window); + +extern void basic_window_set_geometry(void *window,int x, int y, int w, int h); + +extern void basic_window_set_requisition(void *window, int min_w, int min_h, int max_w, int max_h); + +extern void basic_window_set_position(void *window, int x, int y); + +extern void basic_window_set_size(void *window, int x, int y, int width, int height); +extern unsigned int fsoc_count_ceil; +extern unsigned int rsoc_count_ceil; +/*INTEGER_16*/T2 r10to_integer_32(T10 C); +/*INTEGER_16*/T3 r10decimal_digit(T10 C); +/*INTEGER_16*/void r10append_in(T10 C,T0* a1); +extern T9 oBC101sprintf_buffer; +/*REAL_64*/void r5append_in_format(T5 C,T0* a1,T2 a2); +/*POINTER*/T2 r8hash_code(T8 C); +/*INTEGER_32*/T6 r2in_range(T2 C,T2 a1,T2 a2); +/*INTEGER_32*/T2 r2max(T2 C,T2 a1); +/*INTEGER_32*/T3 r2decimal_digit(T2 C); +/*INTEGER_32*/void r2append_in(T2 C,T0* a1); +/*INTEGER_32*/T10 r2high_16(T2 C); +/*CHARACTER*/T6 r3_ix_6261(T3 C,T3 a1); +/*CHARACTER*/T6 r3_ix_6061(T3 C,T3 a1); +/*CHARACTER*/T6 r3is_digit(T3 C); +/*CHARACTER*/T1 r3value(T3 C); +/*CHARACTER*/T6 r3is_separator(T3 C); +/*CHARACTER*/T1 r3decimal_value(T3 C); +/*BOOLEAN*/T6 r6_ix_or(T6 C,T6 a1); +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r290clear_all(T290 C,T2 a1); +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/T290 r290realloc(T290 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r290copy_from(T290 C,T290 a1,T2 a2); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]*/void r289clear_all(T289 C,T2 a1); +/*NATIVE_ARRAY[JOB]*/void r288clear_all(T288 C,T2 a1); +/*NATIVE_ARRAY[JOB]*/void r288remove(T288 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[JOB]*/T288 r288realloc(T288 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[JOB]*/void r288copy_from(T288 C,T288 a1,T2 a2); +/*NATIVE_ARRAY[EVENT_CATCHER]*/void r287clear_all(T287 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]*/void r284clear_all(T284 C,T2 a1); +/*NATIVE_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r281clear_all(T281 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]*/void r276clear_all(T276 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]*/void r270clear_all(T270 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]*/void r267clear_all(T267 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]*/void r263clear_all(T263 C,T2 a1); +/*NATIVE_ARRAY[TOPLEVEL_WINDOW]*/void r262clear_all(T262 C,T2 a1); +/*NATIVE_ARRAY[KEY_RANGE]*/void r261clear_all(T261 C,T2 a1); +/*NATIVE_ARRAY[KEY_RANGE]*/T261 r261realloc(T261 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[KEY_RANGE]*/void r261copy_from(T261 C,T261 a1,T2 a2); +/*NATIVE_ARRAY[BUTTON_RANGE]*/void r260clear_all(T260 C,T2 a1); +/*NATIVE_ARRAY[BUTTON_RANGE]*/T260 r260realloc(T260 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[BUTTON_RANGE]*/void r260copy_from(T260 C,T260 a1,T2 a2); +/*NATIVE_ARRAY[AXES_RANGE]*/void r259clear_all(T259 C,T2 a1); +/*NATIVE_ARRAY[AXES_RANGE]*/T259 r259realloc(T259 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[AXES_RANGE]*/void r259copy_from(T259 C,T259 a1,T2 a2); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]*/void r257clear_all(T257 C,T2 a1); +/*NATIVE_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r255clear_all(T255 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]*/void r251clear_all(T251 C,T2 a1); +/*NATIVE_ARRAY[INTEGER_32]*/void r250set_slice_with(T250 C,T2 a1,T2 a2,T2 a3); +/*NATIVE_ARRAY[INTEGER_32]*/void r250clear_all(T250 C,T2 a1); +/*NATIVE_ARRAY[INTEGER_32]*/void r250set_all_with(T250 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[INTEGER_32]*/T250 r250realloc(T250 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[INTEGER_32]*/void r250copy_from(T250 C,T250 a1,T2 a2); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[POINTER,STRING]]*/void r247clear_all(T247 C,T2 a1); +/*NATIVE_ARRAY[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]*/void r239clear_all(T239 C,T2 a1); +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238clear_all(T238 C,T2 a1); +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238clear(T238 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238remove(T238 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[IVY_CLIENT]*/T238 r238realloc(T238 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[IVY_CLIENT]*/void r238copy_from(T238 C,T238 a1,T2 a2); +/*NATIVE_ARRAY[IVY_CLIENT]*/T2 r238fast_index_of(T238 C,T0* a1,T2 a2,T2 a3); +/*NATIVE_ARRAY[LOOP_ITEM]*/void r237clear_all(T237 C,T2 a1); +/*NATIVE_ARRAY[LOOP_ITEM]*/T237 r237realloc(T237 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[LOOP_ITEM]*/void r237copy_from(T237 C,T237 a1,T2 a2); +/*NATIVE_ARRAY[X_INPUT_DEVICE]*/void r220clear_all(T220 C,T2 a1); +/*NATIVE_ARRAY[STRING]*/void r219clear_all(T219 C,T2 a1); +/*NATIVE_ARRAY[STRING]*/void r219clear(T219 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[STRING]*/T219 r219realloc(T219 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[STRING]*/void r219copy_from(T219 C,T219 a1,T2 a2); +/*NATIVE_ARRAY[CHARACTER]*/void r9clear_all(T9 C,T2 a1); +/*NATIVE_ARRAY[CHARACTER]*/T9 r9realloc(T9 C,T2 a1,T2 a2); +/*NATIVE_ARRAY[CHARACTER]*/void r9copy_from(T9 C,T9 a1,T2 a2); +/*NATIVE_ARRAY[CHARACTER]*/T2 r9fast_index_of(T9 C,T3 a1,T2 a2,T2 a3); +/*NATIVE_ARRAY[CHARACTER]*/void r9copy_at(T9 C,T2 a1,T9 a2,T2 a3); +/*NATIVE_ARRAY[CHARACTER]*/T6 r9fast_memcmp(T9 C,T9 a1,T2 a2); +T7*create7from_external(T8 a1); +/*STRING*/void r7put(T7* C,T3 a1,T2 a2); +/*STRING*/void r7remove_between(T7* C,T2 a1,T2 a2); +/*STRING*/T6 r7is_equal(T7* C,T0* a1); +/*STRING*/void r7append(T7* C,T0* a1); +/*STRING*/void r7copy(T7* C,T0* a1); +/*STRING*/T6 r7is_real(T7* C); +/*STRING*/T2 r7index_of(T7* C,T3 a1,T2 a2); +/*STRING*/T6 r7is_integer(T7* C); +/*STRING*/void r7remove_tail(T7* C,T2 a1); +/*STRING*/T0* r7twin(T7* C); +/*STRING*/void r7extend(T7* C,T3 a1); +/*STRING*/T2 r7hash_code(T7* C); +/*STRING*/void r7remove_last(T7* C); +/*STRING*/void r7add_last(T7* C,T3 a1); +/*STRING*/void r7ensure_capacity(T7* C,T2 a1); +/*STRING*/void r7from_external_copy(T7* C,T8 a1); +/*STRING*/void r7from_external(T7* C,T8 a1); +/*STRING*/T8 r7to_external(T7* C); +/*STRING*/T2 r7to_integer(T7* C); +/*STRING*/void r7remove_head(T7* C,T2 a1); +/*STRING*/void r7swap(T7* C,T2 a1,T2 a2); +/*STRING*/T2 r7first_index_of(T7* C,T3 a1); +/*STRING*/T5 r7to_real(T7* C); +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254make(T254* C,T2 a1); +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254add_last(T254* C,T0* a1); +/*FAST_ARRAY[PROCEDURE[TUPLE[X_INPUT_DEVICE]]]*/void r254mark_native_arrays(T254* C); +/*FAST_ARRAY[JOB]*/void r236remove(T236* C,T2 a1); +/*FAST_ARRAY[JOB]*/void r236make(T236* C,T2 a1); +/*FAST_ARRAY[JOB]*/void r236add_last(T236* C,T0* a1); +/*FAST_ARRAY[JOB]*/T6 r236is_empty(T236* C); +/*FAST_ARRAY[JOB]*/void r236mark_native_arrays(T236* C); +/*FAST_ARRAY[JOB]*/void r236add(T236* C,T0* a1,T2 a2); +/*FAST_ARRAY[JOB]*/void r236move(T236* C,T2 a1,T2 a2,T2 a3); +/*FAST_ARRAY[EVENT_CATCHER]*/void r235make(T235* C,T2 a1); +/*FAST_ARRAY[EVENT_CATCHER]*/void r235mark_native_arrays(T235* C); +/*FAST_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r232make(T232* C,T2 a1); +/*FAST_ARRAY[DICTIONARY[SIGNAL_0,SENSITIVE]]*/void r232mark_native_arrays(T232* C); +/*FAST_ARRAY[TOPLEVEL_WINDOW]*/void r225make(T225* C,T2 a1); +/*FAST_ARRAY[TOPLEVEL_WINDOW]*/void r225mark_native_arrays(T225* C); +/*FAST_ARRAY[KEY_RANGE]*/void r223make(T223* C,T2 a1); +/*FAST_ARRAY[KEY_RANGE]*/void r223add_last(T223* C,T0* a1); +/*FAST_ARRAY[KEY_RANGE]*/void r223mark_native_arrays(T223* C); +/*FAST_ARRAY[BUTTON_RANGE]*/void r222make(T222* C,T2 a1); +/*FAST_ARRAY[BUTTON_RANGE]*/void r222add_last(T222* C,T0* a1); +/*FAST_ARRAY[BUTTON_RANGE]*/void r222mark_native_arrays(T222* C); +/*FAST_ARRAY[AXES_RANGE]*/void r221make(T221* C,T2 a1); +/*FAST_ARRAY[AXES_RANGE]*/void r221add_last(T221* C,T0* a1); +/*FAST_ARRAY[AXES_RANGE]*/void r221mark_native_arrays(T221* C); +/*FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r217make(T217* C,T2 a1); +/*FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]]*/void r217mark_native_arrays(T217* C); +/*FAST_ARRAY[INTEGER_32]*/void r214make(T214* C,T2 a1); +/*FAST_ARRAY[INTEGER_32]*/T2 r214count(T214* C); +/*FAST_ARRAY[IVY_CLIENT]*/void r207copy(T207* C,T0* a1); +/*FAST_ARRAY[IVY_CLIENT]*/void r207remove(T207* C,T2 a1); +/*FAST_ARRAY[IVY_CLIENT]*/void r207make(T207* C,T2 a1); +/*FAST_ARRAY[IVY_CLIENT]*/void r207add_last(T207* C,T0* a1); +/*FAST_ARRAY[IVY_CLIENT]*/void r207mark_native_arrays(T207* C); +/*FAST_ARRAY[IVY_CLIENT]*/T2 r207fast_index_of(T207* C,T0* a1,T2 a2); +/*FAST_ARRAY[LOOP_ITEM]*/void r206remove_last(T206* C); +/*FAST_ARRAY[LOOP_ITEM]*/void r206make(T206* C,T2 a1); +/*FAST_ARRAY[LOOP_ITEM]*/void r206add_last(T206* C,T0* a1); +/*FAST_ARRAY[LOOP_ITEM]*/T0* r206last(T206* C); +/*FAST_ARRAY[LOOP_ITEM]*/T6 r206is_empty(T206* C); +/*FAST_ARRAY[LOOP_ITEM]*/void r206mark_native_arrays(T206* C); +/*FAST_ARRAY[X_INPUT_DEVICE]*/void r205make(T205* C,T2 a1); +/*FAST_ARRAY[X_INPUT_DEVICE]*/void r205mark_native_arrays(T205* C); +/*FAST_ARRAY[STRING]*/void r204make(T204* C,T2 a1); +/*FAST_ARRAY[STRING]*/void r204add_last(T204* C,T0* a1); +/*FAST_ARRAY[STRING]*/void r204with_capacity(T204* C,T2 a1); +/*FAST_ARRAY[STRING]*/void r204mark_native_arrays(T204* C); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_0,SENSITIVE]]*/void r286set_item(T286* C,T0* a1); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]]*/void r277set_item(T277* C,T0* a1); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]]*/void r271set_item(T271* C,T0* a1); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]]*/void r268set_item(T268* C,T0* a1); +/*HASHED_DICTIONARY_NODE[SENSITIVE,POINTER]*/void r266make(T266* C,T0* a1,T8 a2,T0* a3); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]]*/void r265set_item(T265* C,T0* a1); +/*HASHED_DICTIONARY_NODE[EXTENSION_DEVICE,INTEGER_32]*/void r264make(T264* C,T0* a1,T2 a2,T0* a3); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]]*/void r258set_item(T258* C,T0* a1); +/*HASHED_DICTIONARY_NODE[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r256make(T256* C,T0* a1,T0* a2,T0* a3); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]]*/void r253set_item(T253* C,T0* a1); +/*HASHED_DICTIONARY_NODE[INTEGER_32,INTEGER_32]*/void r252make(T252* C,T2 a1,T2 a2,T0* a3); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[POINTER,STRING]]*/void r249set_item(T249* C,T0* a1); +/*HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r246make(T246* C,T0* a1,T0* a2,T0* a3); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]]*/void r245set_item(T245* C,T0* a1); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T2 r244prime_capacity(T2 a1); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T2 r244prime_number_ceiling(T2 a1); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T6 r244should_increase_capacity(T2 a1,T2 a2); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T0* r244new_node(T244* C,T0* a1,T0* a2,T0* a3); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244add(T244* C,T0* a1,T0* a2); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/T0* r244fast_reference_at(T244* C,T0* a1); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244special_common_dictionary(T244* C,T0* a1); +/*HASHED_DICTIONARY[WEAK_REFERENCE[ANY_HASHED_DICTIONARY_NODE],STRING]*/void r244increase_capacity(T244* C); +/*WEAK_REFERENCE[HASHED_DICTIONARY_NODE[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]]*/void r243set_item(T243* C,T0* a1); +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/void r234make(T234* C); +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T0* r234reference_at(T234* C,T0* a1); +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T6 r234key_safe_equal(T0* a1,T0* a2); +extern T0*oBC136common_free_nodes; +extern int fBC136common_free_nodes; +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/T0* r234common_free_nodes(void); +/*HASHED_DICTIONARY[SIGNAL_0,SENSITIVE]*/void r234create_with_capacity(T234* C,T2 a1); +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/void r230make(T230* C); +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r230reference_at(T230* C,T0* a1); +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T6 r230key_safe_equal(T0* a1,T0* a2); +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r230common_free_nodes(void); +/*HASHED_DICTIONARY[SIGNAL_2[INTEGER_32,INTEGER_32],SENSITIVE]*/void r230create_with_capacity(T230* C,T2 a1); +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/void r228make(T228* C); +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r228reference_at(T228* C,T0* a1); +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T6 r228key_safe_equal(T0* a1,T0* a2); +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/T0* r228common_free_nodes(void); +/*HASHED_DICTIONARY[SIGNAL_4[INTEGER_32,INTEGER_32,INTEGER_32,INTEGER_32],SENSITIVE]*/void r228create_with_capacity(T228* C,T2 a1); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227make(T227* C); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T2 r227prime_capacity(T2 a1); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T2 r227prime_number_ceiling(T2 a1); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T6 r227should_increase_capacity(T2 a1,T2 a2); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227reference_at(T227* C,T8 a1); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T6 r227key_safe_equal(T8 a1,T8 a2); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227common_free_nodes(void); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/T0* r227new_node(T227* C,T0* a1,T8 a2,T0* a3); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227add(T227* C,T0* a1,T8 a2); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227create_with_capacity(T227* C,T2 a1); +/*HASHED_DICTIONARY[SENSITIVE,POINTER]*/void r227increase_capacity(T227* C); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226put(T226* C,T0* a1,T2 a2); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226make(T226* C); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T2 r226prime_capacity(T2 a1); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T2 r226prime_number_ceiling(T2 a1); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T6 r226should_increase_capacity(T2 a1,T2 a2); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226reference_at(T226* C,T2 a1); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T6 r226key_safe_equal(T2 a1,T2 a2); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226common_free_nodes(void); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/T0* r226new_node(T226* C,T0* a1,T2 a2,T0* a3); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226create_with_capacity(T226* C,T2 a1); +/*HASHED_DICTIONARY[EXTENSION_DEVICE,INTEGER_32]*/void r226increase_capacity(T226* C); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218make(T218* C); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T2 r218prime_capacity(T2 a1); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T2 r218prime_number_ceiling(T2 a1); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218reference_at(T218* C,T0* a1); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T6 r218should_increase_capacity(T2 a1,T2 a2); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218common_free_nodes(void); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T6 r218key_safe_equal(T0* a1,T0* a2); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/T0* r218new_node(T218* C,T0* a1,T0* a2,T0* a3); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218add(T218* C,T0* a1,T0* a2); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218create_with_capacity(T218* C,T2 a1); +/*HASHED_DICTIONARY[FAST_ARRAY[SIGNAL_1[X_INPUT_DEVICE]],SENSITIVE]*/void r218increase_capacity(T218* C); +/*SIGNAL_1[X_INPUT_DEVICE]*/void r216make(T216* C); +/*SIGNAL_1[X_INPUT_DEVICE]*/void r216emit(T216* C,T0* a1); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215put(T215* C,T2 a1,T2 a2); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215make(T215* C); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215at(T215* C,T2 a1); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215prime_capacity(T2 a1); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T2 r215prime_number_ceiling(T2 a1); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T6 r215should_increase_capacity(T2 a1,T2 a2); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T6 r215key_safe_equal(T2 a1,T2 a2); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T0* r215common_free_nodes(void); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/T0* r215new_node(T215* C,T2 a1,T2 a2,T0* a3); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215create_with_capacity(T215* C,T2 a1); +/*HASHED_DICTIONARY[INTEGER_32,INTEGER_32]*/void r215increase_capacity(T215* C); +/*RING_ARRAY[INTEGER_32]*/void r213put(T213* C,T2 a1,T2 a2); +/*RING_ARRAY[INTEGER_32]*/void r213clear_all(T213* C); +/*RING_ARRAY[INTEGER_32]*/void r213set_all_with(T213* C,T2 a1); +/*RING_ARRAY[INTEGER_32]*/T2 r213wrap_point(T213* C); +/*RING_ARRAY[INTEGER_32]*/void r213make_space_for_one(T213* C); +/*RING_ARRAY[INTEGER_32]*/void r213squeeze_bubble(T213* C,T2 a1,T2 a2,T2 a3,T2 a4); +/*RING_ARRAY[INTEGER_32]*/T2 r213storage_upper(T213* C); +/*RING_ARRAY[INTEGER_32]*/T2 r213storage_index(T213* C,T2 a1); +/*RING_ARRAY[INTEGER_32]*/void r213make(T213* C,T2 a1,T2 a2); +/*RING_ARRAY[INTEGER_32]*/void r213add_last(T213* C,T2 a1); +/*RING_ARRAY[INTEGER_32]*/T2 r213count(T213* C); +/*RING_ARRAY[INTEGER_32]*/T6 r213is_empty(T213* C); +/*RING_ARRAY[INTEGER_32]*/T2 r213item(T213* C,T2 a1); +/*RING_ARRAY[INTEGER_32]*/void r213remove_first(T213* C); +/*RING_ARRAY[INTEGER_32]*/void r213move(T213* C,T2 a1,T2 a2,T2 a3); +/*HASHED_DICTIONARY[POINTER,STRING]*/void r211make(T211* C); +/*HASHED_DICTIONARY[POINTER,STRING]*/T0* r211common_free_nodes(void); +/*HASHED_DICTIONARY[POINTER,STRING]*/void r211create_with_capacity(T211* C,T2 a1); +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/void r208make(T208* C); +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/T0* r208common_free_nodes(void); +/*HASHED_DICTIONARY[PROCEDURE[TUPLE[FAST_ARRAY[STRING]]],STRING]*/void r208create_with_capacity(T208* C,T2 a1); +/*STREAM_EXCEPTION*/void r110expect(T110* C,T0* a1); +/*STREAM_EXCEPTION*/T6 r110occurred(T110* C,T0* a1); +/*STREAM_EXCEPTION*/void r110make(T110* C,T0* a1); +/*CAN_READ_DATA_FROM_STREAM*/void r120expect(T120* C,T0* a1); +/*CAN_READ_DATA_FROM_STREAM*/T6 r120occurred(T120* C,T0* a1); +/*CAN_READ_DATA_FROM_STREAM*/void r120make(T120* C,T0* a1); +/*TIME*/T6 r189_ix_60(T189* C,T189 a1); +/*TIME*/T5 r189elapsed_seconds(T189* C,T189 a1); +/*MICROSECOND_TIME*/T6 r176_ix_60(T176* C,T176 a1); +/*MICROSECOND_TIME*/T5 r176elapsed_seconds(T176* C,T176 a1); +/*MICROSECOND_TIME*/void r176update(T176* C); +/*EVENTS_SET*/void r147reset(T147* C); +/*EVENTS_SET*/void r147expect(T147* C,T0* a1); +/*EVENTS_SET*/void r147make(T147* C); +/*EVENTS_SET*/void r147when_data(T147* C,T0* a1); +/*EVENTS_SET*/T6 r147is_data(T147* C,T0* a1); +/*EVENTS_SET*/void r147when_exception(T147* C,T0* a1); +/*EVENTS_SET*/T6 r147event_occurred(T147* C,T0* a1); +/*EVENTS_SET*/T6 r147is_exception(T147* C,T0* a1); +/*EVENTS_SET*/void r147wait(T147* C); +/*ROOT_LAYOUT*/void r158set_container(T158* C,T0* a1); +/*STD_INPUT*/void r54make(T54* C); +/*STD_INPUT*/void r54dispose(T54* C); +/*KEY_RANGE*/void r139make(T139* C,T8 a1); +/*BUTTON_RANGE*/void r142make(T142* C,T8 a1); +/*AXES_RANGE*/void r141make(T141* C,T8 a1); +/*IVY_CLIENT*/T2 r146descriptor(T146* C); +/*IVY_CLIENT*/T0* r146event_can_read(T146* C); +/*IVY_CLIENT*/void r146make(T146* C,T2 a1,T8 a2,T8 a3,T8 a4); +/*IVY_CLIENT*/void r146process_incomming_data(T146* C); +/*IVY_CLIENT*/void r146disconnect(T146* C); +/*IVY_CLIENT*/void r146dispose(T146* C); +/*IVY_CLIENT*/T0* r146event_exception(T146* C); +T148*create148make(void); +/*LOOP_ITEM*/void r148add_job(T148* C,T0* a1); +/*LOOP_ITEM*/void r148run(T148* C); +/*LOOP_ITEM*/void r148make(T148* C); +/*GRAPHIC_CONNECTION*/T0* r131event_can_read(T131* C); +/*GRAPHIC_CONNECTION*/void r131set_descriptor(T131* C,T2 a1); +/*GRAPHIC_CONNECTION*/T2 r131filtered_descriptor(T131* C); +/*GRAPHIC_CONNECTION*/void r131dispose(T131* C); +/*VISION_LOOP_STACK*/T0* r130current_loop(T130* C); +/*VISION_LOOP_STACK*/void r130add_job(T130* C,T0* a1); +/*VISION_LOOP_STACK*/void r130run(T130* C); +/*VISION_LOOP_STACK*/void r130make(T130* C); +/*VISION_LOOP_STACK*/void r130_P_129_make(T130* C); +/*EVENT_CATCHER*/void r128add_extension(T128* C,T0* a1); +/*EVENT_CATCHER*/T0* r128search_widget(T128* C,T8 a1); +/*EVENT_CATCHER*/void r128prepare(T128* C,T0* a1); +/*EVENT_CATCHER*/void r128emit_event(T128* C,T0* a1,T2 a2); +/*EVENT_CATCHER*/T6 r128is_ready(T128* C,T0* a1); +/*EVENT_CATCHER*/void r128continue(T128* C); +extern T0*oBC26vision; +extern int fBC26vision; +/*EVENT_CATCHER*/T0* r128vision(void); +extern T0*oBC13io; +/*EVENT_CATCHER*/void r128make(T128* C,T0* a1); +/*ROOT_WINDOW*/void r72default_create(T72* C); +/*ROOT_WINDOW*/T0* r72vision(void); +/*ROOT_WINDOW*/T2 r72hash_code(T72* C); +/*ROOT_WINDOW*/void r72container_init(T72* C); +/*STD_OUTPUT*/void r53filtered_flush(T53* C); +/*STD_OUTPUT*/void r53filtered_put_character(T53* C,T3 a1); +extern T0*oBC13std_output; +extern int fBC13std_output; +/*STD_OUTPUT*/T0* r53std_output(void); +/*STD_OUTPUT*/void r53se_atexit(void); +/*STD_OUTPUT*/void r53make(T53* C); +/*STD_OUTPUT*/void r53write_buffer(T53* C); +/*STD_OUTPUT*/void r53flush(T53* C); +/*STD_OUTPUT*/void r53put_string(T53* C,T0* a1); +/*STD_OUTPUT*/void r53put_line(T53* C,T0* a1); +/*STD_OUTPUT*/void r53dispose(T53* C); +extern T0*oBC13std_input; +extern int fBC13std_input; +/*STD_INPUT_OUTPUT*/T0* r46std_input(void); +/*STD_INPUT_OUTPUT*/T0* r46std_output(void); +/*STD_INPUT_OUTPUT*/void r46disconnect(void); +/*STD_INPUT_OUTPUT*/T6 r46is_connected(void); +/*STD_INPUT_OUTPUT*/void r46put_string(T0* a1); +/*STD_INPUT_OUTPUT*/void r46dispose(void); +/*X_INPUT_EXTENSION*/void r175make(T175* C); +/*X11*/void r143default_create(void); +extern T0*oBC143x_input_extension; +extern int fBC143x_input_extension; +/*X11*/T0* r143x_input_extension(void); +/*X11*/T6 r143has_x_input_extension(void); +/*X11*/T0* r143get_atom_name(T2 a1); +/*X11*/T0* r143vision(void); +/*X_INPUT_DEVICE*/void r67handle_event(T67* C,T2 a1,T0* a2); +/*X_INPUT_DEVICE*/T0* r67vision(void); +/*X_INPUT_DEVICE*/void r67when_proximity_out(T67* C,T0* a1,T0* a2); +/*X_INPUT_DEVICE*/void r67connect(T67* C); +/*X_INPUT_DEVICE*/void r67when_button_released(T67* C,T0* a1,T0* a2); +/*X_INPUT_DEVICE*/void r67when_event(T67* C,T2 a1,T0* a2,T0* a3); +/*X_INPUT_DEVICE*/void r67make(T67* C,T8 a1,T2 a2); +/*X_INPUT_DEVICE*/void r67when_moved(T67* C,T0* a1,T0* a2); +/*X_INPUT_DEVICE*/T2 r67proximity_axis_data(T2 a1); +/*X_INPUT_DEVICE*/void r67when_button_pressed(T67* C,T0* a1,T0* a2); +/*X_INPUT_DEVICE*/T2 r67motion_axis_data(T2 a1); +/*X_INPUT_DEVICE*/void r67when_proximity_in(T67* C,T0* a1,T0* a2); +/*STD_ERROR*/void r43put_string(T0* a1); +/*STD_ERROR*/void r43put_line(T0* a1); +/*STD_ERROR*/void r43dispose(T43* C); +/*WACOM_POINTER*/T0* r69type_to_name(T2 a1); +/*WACOM_POINTER*/T5 r69mean(T0* a1); +/*WACOM_POINTER*/void r69update_predicted_position(T69* C,T5 a1,T5 a2,T5 a3); +/*WACOM_POINTER*/T0* r69twin(T69* C); +/*WACOM_POINTER*/void r69make(T69* C,T0* a1); +/*WACOM_POINTER*/void r69print_data_in(T69* C,T0* a1,T2 a2,T2 a3,T2 a4,T2 a5,T2 a6,T2 a7,T2 a8,T0* a9); +/*WACOM_POINTER*/void r69set_message_header(T69* C,T0* a1); +/*WACOM_POINTER*/void r69button(T69* C,T6 a1,T0* a2); +/*WACOM_POINTER*/void r69proximity(T69* C,T6 a1,T0* a2); +/*WACOM_POINTER*/T2 r69device_to_screen_y(T69* C,T2 a1); +/*WACOM_POINTER*/T2 r69device_to_screen_x(T69* C,T2 a1); +/*WACOM_POINTER*/void r69move(T69* C,T0* a1); +/*IVY*/void r70prepare(T70* C,T0* a1); +/*IVY*/T6 r70is_ready(T70* C,T0* a1); +/*IVY*/void r70continue(T70* C); +/*IVY*/void r70channel_down(T70* C,T0* a1); +/*IVY*/void r70callback_runner(T0* a1,T2 a2,T212 a3); +/*IVY*/T0* r70channel_up(T70* C,T2 a1,T8 a2,T8 a3,T8 a4); +/*IVY*/void r70send_message(T70* C,T0* a1); +/*IVY*/void r70make(T70* C,T0* a1); +/*IVY*/void r70start(T70* C,T0* a1); +extern T0*oBC64root_window; +extern int fBC64root_window; +/*VISION*/T0* r64root_window(void); +extern T0*oBC13std_error; +/*VISION*/void r64crash(T64* C); +/*VISION*/void r64not_yet_implemented(T64* C); +/*VISION*/void r64start(T64* C); +/*VISION*/void r64register(T64* C,T0* a1); +/*VISION*/void r64graphic_init(T64* C); +typedef struct _se_agenT25C25l194c40 se_agenT25C25l194c40; +struct _se_agenT25C25l194c40{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l194c40*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l194c40*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T6 c1;}; +typedef struct _se_agent_eqC69C6_r69proximity se_agent_eqC69C6_r69proximity; +struct _se_agent_eqC69C6_r69proximity{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T6 c1;}; +/*agent creation*/T0*agenT25C25l194c40(T0* c0,T6 c1); +void gc_mark_agenT25C25l194c40(se_agenT25C25l194c40*u); +/*agent equality*/int eq_agent_eqC69C6_r69proximity(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l193c39 se_agenT25C25l193c39; +struct _se_agenT25C25l193c39{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l193c39*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l193c39*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T6 c1;}; +/*agent creation*/T0*agenT25C25l193c39(T0* c0,T6 c1); +void gc_mark_agenT25C25l193c39(se_agenT25C25l193c39*u); +typedef struct _se_agenT25C25l192c42 se_agenT25C25l192c42; +struct _se_agenT25C25l192c42{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l192c42*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l192c42*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T6 c1;}; +typedef struct _se_agent_eqC69C6_r69button se_agent_eqC69C6_r69button; +struct _se_agent_eqC69C6_r69button{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T6 c1;}; +/*agent creation*/T0*agenT25C25l192c42(T0* c0,T6 c1); +void gc_mark_agenT25C25l192c42(se_agenT25C25l192c42*u); +/*agent equality*/int eq_agent_eqC69C6_r69button(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l191c41 se_agenT25C25l191c41; +struct _se_agenT25C25l191c41{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l191c41*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l191c41*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T6 c1;}; +/*agent creation*/T0*agenT25C25l191c41(T0* c0,T6 c1); +void gc_mark_agenT25C25l191c41(se_agenT25C25l191c41*u); +typedef struct _se_agenT25C25l190c32 se_agenT25C25l190c32; +struct _se_agenT25C25l190c32{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l190c32*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l190c32*); +int (*eq)(se_agent*,se_agent*); +T0* c0;}; +typedef struct _se_agent_eqC69_r69move se_agent_eqC69_r69move; +struct _se_agent_eqC69_r69move{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;}; +/*agent creation*/T0*agenT25C25l190c32(T0* c0); +void gc_mark_agenT25C25l190c32(se_agenT25C25l190c32*u); +/*agent equality*/int eq_agent_eqC69_r69move(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l173c38 se_agenT25C25l173c38; +struct _se_agenT25C25l173c38{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l173c38*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l173c38*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T0* c1;}; +typedef struct _se_agent_eqC25C7_r25pad_button_released se_agent_eqC25C7_r25pad_button_released; +struct _se_agent_eqC25C7_r25pad_button_released{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T0* c1;}; +/*agent creation*/T0*agenT25C25l173c38(T0* c0,T0* c1); +void gc_mark_agenT25C25l173c38(se_agenT25C25l173c38*u); +/*agent equality*/int eq_agent_eqC25C7_r25pad_button_released(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l172c37 se_agenT25C25l172c37; +struct _se_agenT25C25l172c37{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l172c37*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l172c37*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T0* c1;}; +typedef struct _se_agent_eqC25C7_r25pad_button_pressed se_agent_eqC25C7_r25pad_button_pressed; +struct _se_agent_eqC25C7_r25pad_button_pressed{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T0* c1;}; +/*agent creation*/T0*agenT25C25l172c37(T0* c0,T0* c1); +void gc_mark_agenT25C25l172c37(se_agenT25C25l172c37*u); +/*agent equality*/int eq_agent_eqC25C7_r25pad_button_pressed(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l167c36 se_agenT25C25l167c36; +struct _se_agenT25C25l167c36{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l167c36*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l167c36*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T0* c1;}; +typedef struct _se_agent_eqC25C7_r25left_slider_out se_agent_eqC25C7_r25left_slider_out; +struct _se_agent_eqC25C7_r25left_slider_out{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T0* c1;}; +/*agent creation*/T0*agenT25C25l167c36(T0* c0,T0* c1); +void gc_mark_agenT25C25l167c36(se_agenT25C25l167c36*u); +/*agent equality*/int eq_agent_eqC25C7_r25left_slider_out(se_agent*u1, se_agent*u2); +typedef struct _se_agenT25C25l166c28 se_agenT25C25l166c28; +struct _se_agenT25C25l166c28{Tid id; +int creation_mold_id; +void(*afp)(se_agenT25C25l166c28*,T0*); +void(*gc_mark_agent_mold)(se_agenT25C25l166c28*); +int (*eq)(se_agent*,se_agent*); +T0* c0;T0* c1;}; +typedef struct _se_agent_eqC25C7_r25slider_event se_agent_eqC25C7_r25slider_event; +struct _se_agent_eqC25C7_r25slider_event{Tid id; +int creation_mold_id; +void*afp; +void*gc_mark_agent_mold; +void*eq; +T0* c0;T0* c1;}; +/*agent creation*/T0*agenT25C25l166c28(T0* c0,T0* c1); +void gc_mark_agenT25C25l166c28(se_agenT25C25l166c28*u); +/*agent equality*/int eq_agent_eqC25C7_r25slider_event(se_agent*u1, se_agent*u2); +/*XINPUT_IVY*/T0* r25std_output(void); +/*XINPUT_IVY*/T0* r25vision(void); +/*XINPUT_IVY*/T6 r25decode_options(T25* C); +/*XINPUT_IVY*/void r25list_devices(T25* C); +/*XINPUT_IVY*/void r25print_help(void); +/*XINPUT_IVY*/T6 r25init_pad(T25* C,T0* a1); +/*XINPUT_IVY*/void r25left_slider_out(T25* C,T0* a1,T0* a2); +/*XINPUT_IVY*/void r25pad_button_pressed(T25* C,T0* a1,T0* a2); +/*XINPUT_IVY*/void r25pad_button_released(T25* C,T0* a1,T0* a2); +/*XINPUT_IVY*/T2 r25argument_count(void); +/*XINPUT_IVY*/void r25make(T25* C); +/*XINPUT_IVY*/T0* r25subscribe_input(T25* C,T0* a1); +/*XINPUT_IVY*/T6 r25init_wacom_pointer(T25* C,T0* a1,T0* a2); +/*XINPUT_IVY*/void r25slider_event(T25* C,T0* a1,T0* a2); +extern T0*oBC30command_arguments; +extern int fBC30command_arguments; +/*XINPUT_IVY*/T0* r25command_arguments(void); +void agent_launcher(/*agent*/T0*a); +void agent_launcher_FAST_ARRAY__STRING__(/*agent*/T0*a,T0* a1); +void agent_launcher_INTEGER_32_INTEGER_32(/*agent*/T0*a,T2 a1,T2 a2); +void agent_launcher_INTEGER_32_INTEGER_32_INTEGER_32_INTEGER_32(/*agent*/T0*a,T2 a1,T2 a2,T2 a3,T2 a4); +void agent_launcher_X_INPUT_DEVICE(/*agent*/T0*a,T0* a1); +union _se_agent{T0 s0;se_agent0 u0; +se_agenT25C25l166c28 uagenT25C25l166c28; +se_agenT25C25l167c36 uagenT25C25l167c36; +se_agenT25C25l172c37 uagenT25C25l172c37; +se_agenT25C25l173c38 uagenT25C25l173c38; +se_agenT25C25l190c32 uagenT25C25l190c32; +se_agenT25C25l191c41 uagenT25C25l191c41; +se_agenT25C25l192c42 uagenT25C25l192c42; +se_agenT25C25l193c39 uagenT25C25l193c39; +se_agenT25C25l194c40 uagenT25C25l194c40; +}; +/* +-- ------------------------------------------------------------------------------------------------------------ +-- Copyright notice below. Please read. +-- +-- Copyright(C) 1994-2002: INRIA - LORIA (INRIA Lorraine) - ESIAL U.H.P. - University of Nancy 1 - FRANCE +-- Copyright(C) 2003-2005: INRIA - LORIA (INRIA Lorraine) - I.U.T. Charlemagne - University of Nancy 2 - FRANCE +-- +-- Authors: Dominique COLNET, Philippe RIBET, Cyril ADRIAN, Vincent CROIZIER, Frederic MERIZEN +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +-- documentation files (the "Software"), to deal in the Software without restriction, including without +-- limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, subject to the following +-- conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial +-- portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +-- LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +-- EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +-- AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +-- OR OTHER DEALINGS IN THE SOFTWARE. +-- +-- http://SmartEiffel.loria.fr - SmartEiffel@loria.fr +-- ------------------------------------------------------------------------------------------------------------ +*/ +#define SE_AGENTS 1 +#define EIF_AGENT se_agent* + +se_agent* new_agent(Tid id); + +#ifdef SE_GC_LIB + + typedef struct B_agent gc_agent; + + struct B_agent { + se_agent object; + union { + void *flag; + gc_agent *next; + } header; + }; + + extern gc_agent *store_agent; + extern gc_agent *gc_free_agent; + extern int store_left_agent; + extern fsoc *store_chunk_agent; + extern fsoc H_agent; + extern int gc_info_nb_agent; + + void gc_align_mark_agent(fsoc *c, gc_agent* a); + void gc_sweep_agent(fsoc *c); + +#endif +extern T0*ms69_1874520032; +extern T0*ms25_0bc25c15l360; +extern T0*ms69_22702416; +extern T0*ms69_22702411; +extern T0*ms69_190991; +extern T0*ms143_1472358418; +extern T0*ms69_15980; +extern T0*ms25_0bc25; +extern T0*ms69_188916; +extern T0*ms25_0bc69; +extern T0*ms25_0bc69c15l93; +extern T0*ms69_1501987274; +extern T0*ms25_1403610646; +extern T0*ms25_0; +extern T0*ms69_10739030; +extern T0*ms69_10739024; +extern T0*ms69_10739017; +extern T0*ms25_1959886733; +extern T0*ms25_0bc25c15; +extern T0*ms25_3479972; +extern T0*ms25_21190322; +extern T0*ms69_1756148648; +extern T0*ms69_1756148653; +extern T0*ms69_1619665677; +extern T0*ms69_104371129; +extern T0*ms69_104371267; +extern T0*ms25_314746909; +extern T0*ms25_1638797568; +extern T0*ms69_1961093439; +extern T0*ms69_1699147265; +extern T0*ms69_23436791; +extern T0*ms25_4487261bc69; +extern T0*ms25_694149733; +extern T0*ms69_4738061; +extern T0*ms69_2112369621; +extern T0*ms25_557679246; +extern T0*ms69_1940108584; +extern T0*ms69_952626; +extern T0*ms69_1461; +extern T0*ms69_1466; +extern T0*ms69_4725666; +extern T0*ms69_4725661; +extern T0*ms69_56246305; +extern T0*ms69_2676; +extern T0*ms25_4487261; +extern T0*ms69_1257860908; +extern T0*ms69_56246305bc69; +extern T0*ms25_1403610646bc25; +extern T0*ms69_2057747851; +extern T0*ms25_0bc69c16; +extern T0*ms25_0bc69c15; +extern T0*ms69_586741066; +extern T0*ms25_946366; +extern T0*ms69_475; +extern T0*ms69_697; +T0*se_ms(int c,char*e); +T0*se_string(char*e); +void se_msi1(void); +void se_msi2(void); +void W70callback_runner(void* C,void* a1,T2 a2,T212 a3); +void manifest_string_mark1(void); +void once_function_mark(void); +void gc_start(void); +typedef struct B110 gc110; +struct B110{T110 object;union {void*flag;gc110*next;} header;}; +extern gc110*store110; +extern int store_left110; +extern fsoc*store_chunk110; +extern gc110*gc_free110; +typedef struct B120 gc120; +struct B120{T120 object;union {void*flag;gc120*next;} header;}; +extern gc120*store120; +extern int store_left120; +extern fsoc*store_chunk120; +extern gc120*gc_free120; +extern na_env na_env293; +extern na_env na_env292; +extern na_env na_env291; +extern na_env na_env290; +extern na_env na_env289; +extern na_env na_env288; +extern na_env na_env287; +typedef struct B286 gc286; +struct B286{T286 object;union {void*flag;gc286*next;} header;}; +extern gc286*store286; +extern int store_left286; +extern fsoc*store_chunk286; +extern gc286*gc_free286; +extern na_env na_env284; +extern na_env na_env281; +typedef struct B277 gc277; +struct B277{T277 object;union {void*flag;gc277*next;} header;}; +extern gc277*store277; +extern int store_left277; +extern fsoc*store_chunk277; +extern gc277*gc_free277; +extern na_env na_env276; +typedef struct B271 gc271; +struct B271{T271 object;union {void*flag;gc271*next;} header;}; +extern gc271*store271; +extern int store_left271; +extern fsoc*store_chunk271; +extern gc271*gc_free271; +extern na_env na_env270; +typedef struct B268 gc268; +struct B268{T268 object;union {void*flag;gc268*next;} header;}; +extern gc268*store268; +extern int store_left268; +extern fsoc*store_chunk268; +extern gc268*gc_free268; +extern na_env na_env267; +typedef struct B266 gc266; +struct B266{T266 object;union {void*flag;gc266*next;} header;}; +extern gc266*store266; +extern int store_left266; +extern fsoc*store_chunk266; +extern gc266*gc_free266; +typedef struct B265 gc265; +struct B265{T265 object;union {void*flag;gc265*next;} header;}; +extern gc265*store265; +extern int store_left265; +extern fsoc*store_chunk265; +extern gc265*gc_free265; +typedef struct B264 gc264; +struct B264{T264 object;union {void*flag;gc264*next;} header;}; +extern gc264*store264; +extern int store_left264; +extern fsoc*store_chunk264; +extern gc264*gc_free264; +extern na_env na_env263; +extern na_env na_env262; +extern na_env na_env261; +extern na_env na_env260; +extern na_env na_env259; +typedef struct B258 gc258; +struct B258{T258 object;union {void*flag;gc258*next;} header;}; +extern gc258*store258; +extern int store_left258; +extern fsoc*store_chunk258; +extern gc258*gc_free258; +extern na_env na_env257; +typedef struct B256 gc256; +struct B256{T256 object;union {void*flag;gc256*next;} header;}; +extern gc256*store256; +extern int store_left256; +extern fsoc*store_chunk256; +extern gc256*gc_free256; +extern na_env na_env255; +typedef struct B254 gc254; +struct B254{T254 object;union {void*flag;gc254*next;} header;}; +extern gc254*store254; +extern int store_left254; +extern fsoc*store_chunk254; +extern gc254*gc_free254; +typedef struct B253 gc253; +struct B253{T253 object;union {void*flag;gc253*next;} header;}; +extern gc253*store253; +extern int store_left253; +extern fsoc*store_chunk253; +extern gc253*gc_free253; +typedef struct B252 gc252; +struct B252{T252 object;union {void*flag;gc252*next;} header;}; +extern gc252*store252; +extern int store_left252; +extern fsoc*store_chunk252; +extern gc252*gc_free252; +extern na_env na_env251; +extern na_env na_env250; +typedef struct B249 gc249; +struct B249{T249 object;union {void*flag;gc249*next;} header;}; +extern gc249*store249; +extern int store_left249; +extern fsoc*store_chunk249; +extern gc249*gc_free249; +extern na_env na_env247; +typedef struct B246 gc246; +struct B246{T246 object;union {void*flag;gc246*next;} header;}; +extern gc246*store246; +extern int store_left246; +extern fsoc*store_chunk246; +extern gc246*gc_free246; +typedef struct B245 gc245; +struct B245{T245 object;union {void*flag;gc245*next;} header;}; +extern gc245*store245; +extern int store_left245; +extern fsoc*store_chunk245; +extern gc245*gc_free245; +typedef struct B244 gc244; +struct B244{T244 object;union {void*flag;gc244*next;} header;}; +extern gc244*store244; +extern int store_left244; +extern fsoc*store_chunk244; +extern gc244*gc_free244; +typedef struct B243 gc243; +struct B243{T243 object;union {void*flag;gc243*next;} header;}; +extern gc243*store243; +extern int store_left243; +extern fsoc*store_chunk243; +extern gc243*gc_free243; +extern na_env na_env239; +extern na_env na_env238; +extern na_env na_env237; +typedef struct B147 gc147; +struct B147{T147 object;union {void*flag;gc147*next;} header;}; +extern gc147*store147; +extern int store_left147; +extern fsoc*store_chunk147; +extern gc147*gc_free147; +typedef struct B236 gc236; +struct B236{T236 object;union {void*flag;gc236*next;} header;}; +extern gc236*store236; +extern int store_left236; +extern fsoc*store_chunk236; +extern gc236*gc_free236; +typedef struct B235 gc235; +struct B235{T235 object;union {void*flag;gc235*next;} header;}; +extern gc235*store235; +extern int store_left235; +extern fsoc*store_chunk235; +extern gc235*gc_free235; +typedef struct B234 gc234; +struct B234{T234 object;union {void*flag;gc234*next;} header;}; +extern gc234*store234; +extern int store_left234; +extern fsoc*store_chunk234; +extern gc234*gc_free234; +typedef struct B232 gc232; +struct B232{T232 object;union {void*flag;gc232*next;} header;}; +extern gc232*store232; +extern int store_left232; +extern fsoc*store_chunk232; +extern gc232*gc_free232; +typedef struct B230 gc230; +struct B230{T230 object;union {void*flag;gc230*next;} header;}; +extern gc230*store230; +extern int store_left230; +extern fsoc*store_chunk230; +extern gc230*gc_free230; +typedef struct B228 gc228; +struct B228{T228 object;union {void*flag;gc228*next;} header;}; +extern gc228*store228; +extern int store_left228; +extern fsoc*store_chunk228; +extern gc228*gc_free228; +typedef struct B227 gc227; +struct B227{T227 object;union {void*flag;gc227*next;} header;}; +extern gc227*store227; +extern int store_left227; +extern fsoc*store_chunk227; +extern gc227*gc_free227; +typedef struct B226 gc226; +struct B226{T226 object;union {void*flag;gc226*next;} header;}; +extern gc226*store226; +extern int store_left226; +extern fsoc*store_chunk226; +extern gc226*gc_free226; +typedef struct B225 gc225; +struct B225{T225 object;union {void*flag;gc225*next;} header;}; +extern gc225*store225; +extern int store_left225; +extern fsoc*store_chunk225; +extern gc225*gc_free225; +typedef struct B158 gc158; +struct B158{T158 object;union {void*flag;gc158*next;} header;}; +extern gc158*store158; +extern int store_left158; +extern fsoc*store_chunk158; +extern gc158*gc_free158; +typedef struct B54 gc54; +struct B54{T54 object;union {void*flag;gc54*next;} header;}; +extern gc54*store54; +extern int store_left54; +extern fsoc*store_chunk54; +extern gc54*gc_free54; +typedef struct B139 gc139; +struct B139{T139 object;union {void*flag;gc139*next;} header;}; +extern gc139*store139; +extern int store_left139; +extern fsoc*store_chunk139; +extern gc139*gc_free139; +typedef struct B223 gc223; +struct B223{T223 object;union {void*flag;gc223*next;} header;}; +extern gc223*store223; +extern int store_left223; +extern fsoc*store_chunk223; +extern gc223*gc_free223; +typedef struct B142 gc142; +struct B142{T142 object;union {void*flag;gc142*next;} header;}; +extern gc142*store142; +extern int store_left142; +extern fsoc*store_chunk142; +extern gc142*gc_free142; +typedef struct B222 gc222; +struct B222{T222 object;union {void*flag;gc222*next;} header;}; +extern gc222*store222; +extern int store_left222; +extern fsoc*store_chunk222; +extern gc222*gc_free222; +typedef struct B141 gc141; +struct B141{T141 object;union {void*flag;gc141*next;} header;}; +extern gc141*store141; +extern int store_left141; +extern fsoc*store_chunk141; +extern gc141*gc_free141; +typedef struct B221 gc221; +struct B221{T221 object;union {void*flag;gc221*next;} header;}; +extern gc221*store221; +extern int store_left221; +extern fsoc*store_chunk221; +extern gc221*gc_free221; +extern na_env na_env220; +extern na_env na_env219; +typedef struct B218 gc218; +struct B218{T218 object;union {void*flag;gc218*next;} header;}; +extern gc218*store218; +extern int store_left218; +extern fsoc*store_chunk218; +extern gc218*gc_free218; +typedef struct B217 gc217; +struct B217{T217 object;union {void*flag;gc217*next;} header;}; +extern gc217*store217; +extern int store_left217; +extern fsoc*store_chunk217; +extern gc217*gc_free217; +typedef struct B216 gc216; +struct B216{T216 object;union {void*flag;gc216*next;} header;}; +extern gc216*store216; +extern int store_left216; +extern fsoc*store_chunk216; +extern gc216*gc_free216; +typedef struct B215 gc215; +struct B215{T215 object;union {void*flag;gc215*next;} header;}; +extern gc215*store215; +extern int store_left215; +extern fsoc*store_chunk215; +extern gc215*gc_free215; +typedef struct B214 gc214; +struct B214{T214 object;union {void*flag;gc214*next;} header;}; +extern gc214*store214; +extern int store_left214; +extern fsoc*store_chunk214; +extern gc214*gc_free214; +typedef struct B213 gc213; +struct B213{T213 object;union {void*flag;gc213*next;} header;}; +extern gc213*store213; +extern int store_left213; +extern fsoc*store_chunk213; +extern gc213*gc_free213; +extern na_env na_env212; +typedef struct B211 gc211; +struct B211{T211 object;union {void*flag;gc211*next;} header;}; +extern gc211*store211; +extern int store_left211; +extern fsoc*store_chunk211; +extern gc211*gc_free211; +typedef struct B208 gc208; +struct B208{T208 object;union {void*flag;gc208*next;} header;}; +extern gc208*store208; +extern int store_left208; +extern fsoc*store_chunk208; +extern gc208*gc_free208; +typedef struct B146 gc146; +struct B146{T146 object;union {void*flag;gc146*next;} header;}; +extern gc146*store146; +extern int store_left146; +extern fsoc*store_chunk146; +extern gc146*gc_free146; +typedef struct B207 gc207; +struct B207{T207 object;union {void*flag;gc207*next;} header;}; +extern gc207*store207; +extern int store_left207; +extern fsoc*store_chunk207; +extern gc207*gc_free207; +typedef struct B206 gc206; +struct B206{T206 object;union {void*flag;gc206*next;} header;}; +extern gc206*store206; +extern int store_left206; +extern fsoc*store_chunk206; +extern gc206*gc_free206; +typedef struct B148 gc148; +struct B148{T148 object;union {void*flag;gc148*next;} header;}; +extern gc148*store148; +extern int store_left148; +extern fsoc*store_chunk148; +extern gc148*gc_free148; +typedef struct B131 gc131; +struct B131{T131 object;union {void*flag;gc131*next;} header;}; +extern gc131*store131; +extern int store_left131; +extern fsoc*store_chunk131; +extern gc131*gc_free131; +typedef struct B130 gc130; +struct B130{T130 object;union {void*flag;gc130*next;} header;}; +extern gc130*store130; +extern int store_left130; +extern fsoc*store_chunk130; +extern gc130*gc_free130; +typedef struct B128 gc128; +struct B128{T128 object;union {void*flag;gc128*next;} header;}; +extern gc128*store128; +extern int store_left128; +extern fsoc*store_chunk128; +extern gc128*gc_free128; +typedef struct B72 gc72; +struct B72{T72 object;union {void*flag;gc72*next;} header;}; +extern gc72*store72; +extern int store_left72; +extern fsoc*store_chunk72; +extern gc72*gc_free72; +typedef struct B53 gc53; +struct B53{T53 object;union {void*flag;gc53*next;} header;}; +extern gc53*store53; +extern int store_left53; +extern fsoc*store_chunk53; +extern gc53*gc_free53; +typedef struct B46 gc46; +struct B46{T46 object;union {void*flag;gc46*next;} header;}; +extern gc46*store46; +extern int store_left46; +extern fsoc*store_chunk46; +extern gc46*gc_free46; +typedef struct B175 gc175; +struct B175{T175 object;union {void*flag;gc175*next;} header;}; +extern gc175*store175; +extern int store_left175; +extern fsoc*store_chunk175; +extern gc175*gc_free175; +typedef struct B205 gc205; +struct B205{T205 object;union {void*flag;gc205*next;} header;}; +extern gc205*store205; +extern int store_left205; +extern fsoc*store_chunk205; +extern gc205*gc_free205; +typedef struct B204 gc204; +struct B204{T204 object;union {void*flag;gc204*next;} header;}; +extern gc204*store204; +extern int store_left204; +extern fsoc*store_chunk204; +extern gc204*gc_free204; + +#define gc_mark202(x) (((se_agent0*)(x))->gc_mark_agent_mold((se_agent*)(x))) + +typedef struct B67 gc67; +struct B67{T67 object;union {void*flag;gc67*next;} header;}; +extern gc67*store67; +extern int store_left67; +extern fsoc*store_chunk67; +extern gc67*gc_free67; +typedef struct B43 gc43; +struct B43{T43 object;union {void*flag;gc43*next;} header;}; +extern gc43*store43; +extern int store_left43; +extern fsoc*store_chunk43; +extern gc43*gc_free43; +typedef struct B69 gc69; +struct B69{T69 object;union {void*flag;gc69*next;} header;}; +extern gc69*store69; +extern int store_left69; +extern fsoc*store_chunk69; +extern gc69*gc_free69; +extern na_env na_env9; +typedef struct B7 gc7; +struct B7{T7 object;union {void*flag;gc7*next;} header;}; +extern gc7*store7; +extern int store_left7; +extern fsoc*store_chunk7; +extern gc7*gc_free7; +typedef struct B70 gc70; +struct B70{T70 object;union {void*flag;gc70*next;} header;}; +extern gc70*store70; +extern int store_left70; +extern fsoc*store_chunk70; +extern gc70*gc_free70; +typedef struct B64 gc64; +struct B64{T64 object;union {void*flag;gc64*next;} header;}; +extern gc64*store64; +extern int store_left64; +extern fsoc*store_chunk64; +extern gc64*gc_free64; +typedef struct B25 gc25; +struct B25{T25 object;union {void*flag;gc25*next;} header;}; +extern gc25*store25; +extern int store_left25; +extern fsoc*store_chunk25; +extern gc25*gc_free25; +void gc_sweep110(fsoc*c); +void gc_mark110(T110*o); +void gc_align_mark110(fsoc*c,gc110*p); +extern fsoc H110; +T110*new110(void); +void gc_sweep120(fsoc*c); +void gc_mark120(T120*o); +void gc_align_mark120(fsoc*c,gc120*p); +extern fsoc H120; +T120*new120(void); +void gc_mark293(T293 o); +T293 new293(unsigned int size); +void gc_mark292(T292 o); +T292 new292(unsigned int size); +void gc_mark291(T291 o); +T291 new291(unsigned int size); +void gc_mark290(T290 o); +T290 new290(unsigned int size); +void gc_mark289(T289 o); +T289 new289(unsigned int size); +void gc_mark288(T288 o); +T288 new288(unsigned int size); +void gc_mark287(T287 o); +T287 new287(unsigned int size); +void gc_sweep286(fsoc*c); +void gc_update_weak_ref_item_polymorph(T0** item); +void gc_mark286(T286*o); +void gc_align_mark286(fsoc*c,gc286*p); +extern fsoc H286; +T286*new286(void); +void gc_mark284(T284 o); +T284 new284(unsigned int size); +void gc_mark281(T281 o); +T281 new281(unsigned int size); +void gc_sweep277(fsoc*c); +void gc_mark277(T277*o); +void gc_align_mark277(fsoc*c,gc277*p); +extern fsoc H277; +T277*new277(void); +void gc_mark276(T276 o); +T276 new276(unsigned int size); +void gc_sweep271(fsoc*c); +void gc_mark271(T271*o); +void gc_align_mark271(fsoc*c,gc271*p); +extern fsoc H271; +T271*new271(void); +void gc_mark270(T270 o); +T270 new270(unsigned int size); +void gc_sweep268(fsoc*c); +void gc_update_weak_ref_item268(T268* wr); +void gc_mark268(T268*o); +void gc_align_mark268(fsoc*c,gc268*p); +extern fsoc H268; +T268*new268(void); +void gc_mark267(T267 o); +T267 new267(unsigned int size); +void gc_sweep266(fsoc*c); +void gc_mark266(T266*o); +void gc_align_mark266(fsoc*c,gc266*p); +extern fsoc H266; +T266*new266(void); +void gc_sweep265(fsoc*c); +void gc_update_weak_ref_item265(T265* wr); +void gc_mark265(T265*o); +void gc_align_mark265(fsoc*c,gc265*p); +extern fsoc H265; +T265*new265(void); +void gc_sweep264(fsoc*c); +void gc_mark264(T264*o); +void gc_align_mark264(fsoc*c,gc264*p); +extern fsoc H264; +T264*new264(void); +void gc_mark263(T263 o); +T263 new263(unsigned int size); +void gc_mark262(T262 o); +T262 new262(unsigned int size); +void gc_mark261(T261 o); +T261 new261(unsigned int size); +void gc_mark260(T260 o); +T260 new260(unsigned int size); +void gc_mark259(T259 o); +T259 new259(unsigned int size); +void gc_sweep258(fsoc*c); +void gc_update_weak_ref_item258(T258* wr); +void gc_mark258(T258*o); +void gc_align_mark258(fsoc*c,gc258*p); +extern fsoc H258; +T258*new258(void); +void gc_mark257(T257 o); +T257 new257(unsigned int size); +void gc_sweep256(fsoc*c); +void gc_mark256(T256*o); +void gc_align_mark256(fsoc*c,gc256*p); +extern fsoc H256; +T256*new256(void); +void gc_mark255(T255 o); +T255 new255(unsigned int size); +void gc_sweep254(fsoc*c); +void gc_mark254(T254*o); +void gc_align_mark254(fsoc*c,gc254*p); +extern fsoc H254; +T254*new254(void); +void gc_sweep253(fsoc*c); +void gc_update_weak_ref_item253(T253* wr); +void gc_mark253(T253*o); +void gc_align_mark253(fsoc*c,gc253*p); +extern fsoc H253; +T253*new253(void); +void gc_sweep252(fsoc*c); +void gc_mark252(T252*o); +void gc_align_mark252(fsoc*c,gc252*p); +extern fsoc H252; +T252*new252(void); +void gc_mark251(T251 o); +T251 new251(unsigned int size); +void gc_mark250(T250 o); +T250 new250(unsigned int size); +void gc_sweep249(fsoc*c); +void gc_mark249(T249*o); +void gc_align_mark249(fsoc*c,gc249*p); +extern fsoc H249; +T249*new249(void); +void gc_mark247(T247 o); +T247 new247(unsigned int size); +void gc_sweep246(fsoc*c); +void gc_mark246(T246*o); +void gc_align_mark246(fsoc*c,gc246*p); +extern fsoc H246; +T246*new246(void); +void gc_sweep245(fsoc*c); +void gc_update_weak_ref_item245(T245* wr); +void gc_mark245(T245*o); +void gc_align_mark245(fsoc*c,gc245*p); +extern fsoc H245; +T245*new245(void); +void gc_sweep244(fsoc*c); +void gc_mark244(T244*o); +void gc_align_mark244(fsoc*c,gc244*p); +extern fsoc H244; +T244*new244(void); +void gc_sweep243(fsoc*c); +void gc_mark243(T243*o); +void gc_align_mark243(fsoc*c,gc243*p); +extern fsoc H243; +T243*new243(void); +void gc_mark239(T239 o); +T239 new239(unsigned int size); +void gc_mark238(T238 o); +T238 new238(unsigned int size); +void gc_mark237(T237 o); +T237 new237(unsigned int size); +void gc_sweep147(fsoc*c); +void gc_mark147(T147*o); +void gc_align_mark147(fsoc*c,gc147*p); +extern fsoc H147; +T147*new147(void); +void gc_sweep236(fsoc*c); +void gc_mark236(T236*o); +void gc_align_mark236(fsoc*c,gc236*p); +extern fsoc H236; +T236*new236(void); +void gc_sweep235(fsoc*c); +void gc_mark235(T235*o); +void gc_align_mark235(fsoc*c,gc235*p); +extern fsoc H235; +T235*new235(void); +void gc_sweep234(fsoc*c); +void gc_mark234(T234*o); +void gc_align_mark234(fsoc*c,gc234*p); +extern fsoc H234; +T234*new234(void); +void gc_sweep232(fsoc*c); +void gc_mark232(T232*o); +void gc_align_mark232(fsoc*c,gc232*p); +extern fsoc H232; +T232*new232(void); +void gc_sweep230(fsoc*c); +void gc_mark230(T230*o); +void gc_align_mark230(fsoc*c,gc230*p); +extern fsoc H230; +T230*new230(void); +void gc_sweep228(fsoc*c); +void gc_mark228(T228*o); +void gc_align_mark228(fsoc*c,gc228*p); +extern fsoc H228; +T228*new228(void); +void gc_sweep227(fsoc*c); +void gc_mark227(T227*o); +void gc_align_mark227(fsoc*c,gc227*p); +extern fsoc H227; +T227*new227(void); +void gc_sweep226(fsoc*c); +void gc_mark226(T226*o); +void gc_align_mark226(fsoc*c,gc226*p); +extern fsoc H226; +T226*new226(void); +void gc_sweep225(fsoc*c); +void gc_mark225(T225*o); +void gc_align_mark225(fsoc*c,gc225*p); +extern fsoc H225; +T225*new225(void); +void gc_sweep158(fsoc*c); +void gc_mark158(T158*o); +void gc_align_mark158(fsoc*c,gc158*p); +extern fsoc H158; +T158*new158(void); +void gc_sweep54(fsoc*c); +void gc_mark54(T54*o); +void gc_align_mark54(fsoc*c,gc54*p); +extern fsoc H54; +T54*new54(void); +void gc_sweep139(fsoc*c); +void gc_mark139(T139*o); +void gc_align_mark139(fsoc*c,gc139*p); +extern fsoc H139; +T139*new139(void); +void gc_sweep223(fsoc*c); +void gc_mark223(T223*o); +void gc_align_mark223(fsoc*c,gc223*p); +extern fsoc H223; +T223*new223(void); +void gc_sweep142(fsoc*c); +void gc_mark142(T142*o); +void gc_align_mark142(fsoc*c,gc142*p); +extern fsoc H142; +T142*new142(void); +void gc_sweep222(fsoc*c); +void gc_mark222(T222*o); +void gc_align_mark222(fsoc*c,gc222*p); +extern fsoc H222; +T222*new222(void); +void gc_sweep141(fsoc*c); +void gc_mark141(T141*o); +void gc_align_mark141(fsoc*c,gc141*p); +extern fsoc H141; +T141*new141(void); +void gc_sweep221(fsoc*c); +void gc_mark221(T221*o); +void gc_align_mark221(fsoc*c,gc221*p); +extern fsoc H221; +T221*new221(void); +void gc_mark220(T220 o); +T220 new220(unsigned int size); +void gc_mark219(T219 o); +T219 new219(unsigned int size); +void gc_sweep218(fsoc*c); +void gc_mark218(T218*o); +void gc_align_mark218(fsoc*c,gc218*p); +extern fsoc H218; +T218*new218(void); +void gc_sweep217(fsoc*c); +void gc_mark217(T217*o); +void gc_align_mark217(fsoc*c,gc217*p); +extern fsoc H217; +T217*new217(void); +void gc_sweep216(fsoc*c); +void gc_mark216(T216*o); +void gc_align_mark216(fsoc*c,gc216*p); +extern fsoc H216; +T216*new216(void); +void gc_sweep215(fsoc*c); +void gc_mark215(T215*o); +void gc_align_mark215(fsoc*c,gc215*p); +extern fsoc H215; +T215*new215(void); +void gc_sweep214(fsoc*c); +void gc_mark214(T214*o); +void gc_align_mark214(fsoc*c,gc214*p); +extern fsoc H214; +T214*new214(void); +void gc_sweep213(fsoc*c); +void gc_mark213(T213*o); +void gc_align_mark213(fsoc*c,gc213*p); +extern fsoc H213; +T213*new213(void); +void gc_mark212(T212 o); +T212 new212(unsigned int size); +void gc_sweep211(fsoc*c); +void gc_mark211(T211*o); +void gc_align_mark211(fsoc*c,gc211*p); +extern fsoc H211; +T211*new211(void); +void gc_sweep208(fsoc*c); +void gc_mark208(T208*o); +void gc_align_mark208(fsoc*c,gc208*p); +extern fsoc H208; +T208*new208(void); +void gc_sweep146(fsoc*c); +void gc_mark146(T146*o); +void gc_align_mark146(fsoc*c,gc146*p); +extern fsoc H146; +T146*new146(void); +void gc_sweep207(fsoc*c); +void gc_mark207(T207*o); +void gc_align_mark207(fsoc*c,gc207*p); +extern fsoc H207; +T207*new207(void); +void gc_sweep206(fsoc*c); +void gc_mark206(T206*o); +void gc_align_mark206(fsoc*c,gc206*p); +extern fsoc H206; +T206*new206(void); +void gc_sweep148(fsoc*c); +void gc_mark148(T148*o); +void gc_align_mark148(fsoc*c,gc148*p); +extern fsoc H148; +T148*new148(void); +void gc_sweep131(fsoc*c); +void gc_mark131(T131*o); +void gc_align_mark131(fsoc*c,gc131*p); +extern fsoc H131; +T131*new131(void); +void gc_sweep130(fsoc*c); +void gc_mark130(T130*o); +void gc_align_mark130(fsoc*c,gc130*p); +extern fsoc H130; +T130*new130(void); +void gc_sweep128(fsoc*c); +void gc_mark128(T128*o); +void gc_align_mark128(fsoc*c,gc128*p); +extern fsoc H128; +T128*new128(void); +void gc_sweep72(fsoc*c); +void gc_mark72(T72*o); +void gc_align_mark72(fsoc*c,gc72*p); +extern fsoc H72; +T72*new72(void); +void gc_sweep53(fsoc*c); +void gc_mark53(T53*o); +void gc_align_mark53(fsoc*c,gc53*p); +extern fsoc H53; +T53*new53(void); +void gc_sweep46(fsoc*c); +void gc_mark46(T46*o); +void gc_align_mark46(fsoc*c,gc46*p); +extern fsoc H46; +T46*new46(void); +void gc_sweep175(fsoc*c); +void gc_mark175(T175*o); +void gc_align_mark175(fsoc*c,gc175*p); +extern fsoc H175; +T175*new175(void); +void gc_sweep205(fsoc*c); +void gc_mark205(T205*o); +void gc_align_mark205(fsoc*c,gc205*p); +extern fsoc H205; +T205*new205(void); +void gc_sweep204(fsoc*c); +void gc_mark204(T204*o); +void gc_align_mark204(fsoc*c,gc204*p); +extern fsoc H204; +T204*new204(void); +void gc_sweep67(fsoc*c); +void gc_mark67(T67*o); +void gc_align_mark67(fsoc*c,gc67*p); +extern fsoc H67; +T67*new67(void); +void gc_sweep43(fsoc*c); +void gc_mark43(T43*o); +void gc_align_mark43(fsoc*c,gc43*p); +extern fsoc H43; +T43*new43(void); +void gc_sweep69(fsoc*c); +void gc_mark69(T69*o); +void gc_align_mark69(fsoc*c,gc69*p); +extern fsoc H69; +T69*new69(void); +void gc_mark9(T9 o); +T9 new9(unsigned int size); +void gc_sweep7(fsoc*c); +void gc_mark7(T7*o); +void gc_align_mark7(fsoc*c,gc7*p); +extern fsoc H7; +T7*new7(void); +void gc_sweep70(fsoc*c); +void gc_mark70(T70*o); +void gc_align_mark70(fsoc*c,gc70*p); +extern fsoc H70; +T70*new70(void); +void gc_sweep64(fsoc*c); +void gc_mark64(T64*o); +void gc_align_mark64(fsoc*c,gc64*p); +extern fsoc H64; +T64*new64(void); +void gc_sweep25(fsoc*c); +void gc_mark25(T25*o); +void gc_align_mark25(fsoc*c,gc25*p); +extern fsoc H25; +T25*new25(void); +void Xgc_mark242(T0*o); +void Xgc_mark49(T0*o); +void Xgc_mark71(T0*o); +extern T25*eiffel_root_object; +extern int se_argc; +extern char**se_argv; +#define SE_MAXID 294 +extern T7*g[]; +extern T7*t[]; +extern int se_strucT[]; +void se_atexit(void); +void initialize_eiffel_runtime(int argc,char*argv[]); +int main(int argc,char*argv[]); +void X71prepare(T0*C,T0* a1); +T2 X71priority(T0*C); +T6 X71done(T0*C); +T6 X71is_ready(T0*C,T0* a1); +void X71continue(T0*C); +void X109expect(T0*C,T0* a1); +T6 X109occurred(T0*C,T0* a1); +T2 X49descriptor(T0*C); +T2 X49filtered_descriptor(T0*C); + +#ifdef __cplusplus +} +#endif -- cgit v1.1