filename
stringlengths 3
9
| code
stringlengths 4
2.03M
|
|---|---|
126704.c | //*****************************************************************************
//
// usb_serial_structs.c - Data structures defining this CDC USB device.
//
// Copyright (c) 2008-2015 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 2.1.2.111 of the DK-TM4C123G Firmware Package.
//
//*****************************************************************************
#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_types.h"
#include "driverlib/usb.h"
#include "usblib/usblib.h"
#include "usblib/usbcdc.h"
#include "usblib/usb-ids.h"
#include "usblib/device/usbdevice.h"
#include "usblib/device/usbdcdc.h"
#include "usb_serial_structs.h"
//*****************************************************************************
//
// The languages supported by this device.
//
//*****************************************************************************
const uint8_t g_pui8LangDescriptor[] = {
4,
USB_DTYPE_STRING,
USBShort(USB_LANG_EN_US)
};
//*****************************************************************************
//
// The manufacturer string.
//
//*****************************************************************************
const uint8_t g_pui8ManufacturerString[] = {
(17 + 1) * 2,
USB_DTYPE_STRING,
'T', 0, 'e', 0, 'x', 0, 'a', 0, 's', 0, ' ', 0, 'I', 0, 'n', 0, 's', 0,
't', 0, 'r', 0, 'u', 0, 'm', 0, 'e', 0, 'n', 0, 't', 0, 's', 0,
};
//*****************************************************************************
//
// The product string.
//
//*****************************************************************************
const uint8_t g_pui8ProdectString[] = {
2 + (16 * 2),
USB_DTYPE_STRING,
'V', 0, 'i', 0, 'r', 0, 't', 0, 'u', 0, 'a', 0, 'l', 0, ' ', 0,
'C', 0, 'O', 0, 'M', 0, ' ', 0, 'P', 0, 'o', 0, 'r', 0, 't', 0
};
//*****************************************************************************
//
// The serial number string.
//
//*****************************************************************************
const uint8_t g_pui8SerialNumberString[] = {
2 + (8 * 2),
USB_DTYPE_STRING,
'1', 0, '2', 0, '3', 0, '4', 0, '5', 0, '6', 0, '7', 0, '8', 0
};
//*****************************************************************************
//
// The control interface description string.
//
//*****************************************************************************
const uint8_t g_pui8ControlInterfaceString[] = {
2 + (21 * 2),
USB_DTYPE_STRING,
'A', 0, 'C', 0, 'M', 0, ' ', 0, 'C', 0, 'o', 0, 'n', 0, 't', 0,
'r', 0, 'o', 0, 'l', 0, ' ', 0, 'I', 0, 'n', 0, 't', 0, 'e', 0,
'r', 0, 'f', 0, 'a', 0, 'c', 0, 'e', 0
};
//*****************************************************************************
//
// The configuration description string.
//
//*****************************************************************************
const uint8_t g_pui8ConfigString[] = {
2 + (26 * 2),
USB_DTYPE_STRING,
'S', 0, 'e', 0, 'l', 0, 'f', 0, ' ', 0, 'P', 0, 'o', 0, 'w', 0,
'e', 0, 'r', 0, 'e', 0, 'd', 0, ' ', 0, 'C', 0, 'o', 0, 'n', 0,
'f', 0, 'i', 0, 'g', 0, 'u', 0, 'r', 0, 'a', 0, 't', 0, 'i', 0,
'o', 0, 'n', 0
};
//*****************************************************************************
//
// The descriptor string table.
//
//*****************************************************************************
const uint8_t * const g_pui8StringDescriptors[] = {
g_pui8LangDescriptor,
g_pui8ManufacturerString,
g_pui8ProdectString,
g_pui8SerialNumberString,
g_pui8ControlInterfaceString,
g_pui8ConfigString
};
#define NUM_STRING_DESCRIPTORS (sizeof(g_pui8StringDescriptors) / \
sizeof(uint8_t *))
//*****************************************************************************
//
// CDC device callback function prototypes.
//
//*****************************************************************************
uint32_t RxHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData);
uint32_t TxHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData);
uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData);
//*****************************************************************************
//
// The CDC device initialization and customization structures. In this case,
// we are using USBBuffers between the CDC device class driver and the
// application code. The function pointers and callback data values are set
// to insert a buffer in each of the data channels, transmit and receive.
//
// With the buffer in place, the CDC channel callback is set to the relevant
// channel function and the callback data is set to point to the channel
// instance data. The buffer, in turn, has its callback set to the application
// function and the callback data set to our CDC instance structure.
//
//*****************************************************************************
tUSBDCDCDevice g_sCDCDevice = {
USB_VID_TI_1CBE,
USB_PID_SERIAL,
0,
USB_CONF_ATTR_SELF_PWR,
ControlHandler,
(void *)&g_sCDCDevice,
USBBufferEventCallback,
(void *)&g_sRxBuffer,
USBBufferEventCallback,
(void *)&g_sTxBuffer,
g_pui8StringDescriptors,
NUM_STRING_DESCRIPTORS
};
//*****************************************************************************
//
// Receive buffer (from the USB perspective).
//
//*****************************************************************************
uint8_t g_pi8USBRxBuffer[UART_BUFFER_SIZE];
tUSBBuffer g_sRxBuffer = {
false, // This is a receive buffer.
RxHandler, // pfnCallback
(void *)&g_sCDCDevice, // Callback data is our device pointer.
USBDCDCPacketRead, // pfnTransfer
USBDCDCRxPacketAvailable, // pfnAvailable
(void *)&g_sCDCDevice, // pvHandle
g_pi8USBRxBuffer, // pi8Buffer
UART_BUFFER_SIZE, // ui32BufferSize
};
//*****************************************************************************
//
// Transmit buffer (from the USB perspective).
//
//*****************************************************************************
uint8_t g_pi8USBTxBuffer[UART_BUFFER_SIZE];
tUSBBuffer g_sTxBuffer = {
true, // This is a transmit buffer.
TxHandler, // pfnCallback
(void *)&g_sCDCDevice, // Callback data is our device pointer.
USBDCDCPacketWrite, // pfnTransfer
USBDCDCTxPacketAvailable, // pfnAvailable
(void *)&g_sCDCDevice, // pvHandle
g_pi8USBTxBuffer, // pi8Buffer
UART_BUFFER_SIZE, // ui32BufferSize
};
|
488493.c | /*
* Copyright (C) by Argonne National Laboratory
* See COPYRIGHT in top-level directory
*/
/* This test checks for large count functionality ("MPI_Count") mandated by
* MPI-3, as well as behavior of corresponding pre-MPI-3 interfaces that now
* have better defined behavior when an "int" quantity would overflow. */
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include "mpitest.h"
/* assert-like macro that bumps the err count and emits a message */
#define check(x_) \
do { \
if (!(x_)) { \
++errs; \
if (errs < 10) { \
fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \
} \
} \
} while (0)
int main(int argc, char *argv[])
{
int errs = 0;
int wrank, wsize;
int size, elements, count;
MPI_Aint lb, extent;
MPI_Count size_x, lb_x, extent_x, elements_x;
MPI_Count imx4i_true_extent;
MPI_Datatype imax_contig = MPI_DATATYPE_NULL;
MPI_Datatype four_ints = MPI_DATATYPE_NULL;
MPI_Datatype imx4i = MPI_DATATYPE_NULL;
MPI_Datatype imx4i_rsz = MPI_DATATYPE_NULL;
MPI_Status status;
MTest_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
MPI_Comm_size(MPI_COMM_WORLD, &wsize);
check(sizeof(MPI_Count) >= sizeof(int));
check(sizeof(MPI_Count) >= sizeof(MPI_Aint));
check(sizeof(MPI_Count) >= sizeof(MPI_Offset));
/* the following two checks aren't explicitly required by the standard, but
* it's hard to imagine a world without them holding true and so most of the
* subsequent code probably depends on them to some degree */
check(sizeof(MPI_Aint) >= sizeof(int));
check(sizeof(MPI_Offset) >= sizeof(int));
/* not much point in checking for integer overflow cases if MPI_Count is
* only as large as an int */
if (sizeof(MPI_Count) == sizeof(int))
goto epilogue;
/* a very large type */
MPI_Type_contiguous(INT_MAX, MPI_CHAR, &imax_contig);
MPI_Type_commit(&imax_contig);
/* a small-ish contig */
MPI_Type_contiguous(4, MPI_INT, &four_ints);
MPI_Type_commit(&four_ints);
/* a type with size>INT_MAX */
MPI_Type_vector(INT_MAX / 2, 1, 3, four_ints, &imx4i);
MPI_Type_commit(&imx4i);
/* don't forget, ub for dtype w/ stride doesn't include any holes at the end
* of the type, hence the more complicated calculation below */
imx4i_true_extent = 3LL * 4LL * sizeof(int) * ((INT_MAX / 2) - 1) + 4LL * sizeof(int);
/* sanity check that the MPI_COUNT predefined named datatype exists */
MPI_Send(&imx4i_true_extent, 1, MPI_COUNT, MPI_PROC_NULL, 0, MPI_COMM_SELF);
/* the same oversized type but with goofy extents */
MPI_Type_create_resized(imx4i, /*lb= */ INT_MAX, /*extent= */ -1024, &imx4i_rsz);
MPI_Type_commit(&imx4i_rsz);
/* MPI_Type_size */
MPI_Type_size(imax_contig, &size);
check(size == INT_MAX);
MPI_Type_size(four_ints, &size);
check(size == 4 * sizeof(int));
MPI_Type_size(imx4i, &size);
check(size == MPI_UNDEFINED); /* should overflow an int */
MPI_Type_size(imx4i_rsz, &size);
check(size == MPI_UNDEFINED); /* should overflow an int */
/* MPI_Type_size_x */
MPI_Type_size_x(imax_contig, &size_x);
check(size_x == INT_MAX);
MPI_Type_size_x(four_ints, &size_x);
check(size_x == 4 * sizeof(int));
MPI_Type_size_x(imx4i, &size_x);
check(size_x == 4LL * sizeof(int) * (INT_MAX / 2)); /* should overflow an int */
MPI_Type_size_x(imx4i_rsz, &size_x);
check(size_x == 4LL * sizeof(int) * (INT_MAX / 2)); /* should overflow an int */
/* MPI_Type_get_extent */
MPI_Type_get_extent(imax_contig, &lb, &extent);
check(lb == 0);
check(extent == INT_MAX);
MPI_Type_get_extent(four_ints, &lb, &extent);
check(lb == 0);
check(extent == 4 * sizeof(int));
MPI_Type_get_extent(imx4i, &lb, &extent);
check(lb == 0);
if (sizeof(MPI_Aint) == sizeof(int))
check(extent == MPI_UNDEFINED);
else
check(extent == imx4i_true_extent);
MPI_Type_get_extent(imx4i_rsz, &lb, &extent);
check(lb == INT_MAX);
check(extent == -1024);
/* MPI_Type_get_extent_x */
MPI_Type_get_extent_x(imax_contig, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == INT_MAX);
MPI_Type_get_extent_x(four_ints, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == 4 * sizeof(int));
MPI_Type_get_extent_x(imx4i, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == imx4i_true_extent);
MPI_Type_get_extent_x(imx4i_rsz, &lb_x, &extent_x);
check(lb_x == INT_MAX);
check(extent_x == -1024);
/* MPI_Type_get_true_extent */
MPI_Type_get_true_extent(imax_contig, &lb, &extent);
check(lb == 0);
check(extent == INT_MAX);
MPI_Type_get_true_extent(four_ints, &lb, &extent);
check(lb == 0);
check(extent == 4 * sizeof(int));
MPI_Type_get_true_extent(imx4i, &lb, &extent);
check(lb == 0);
if (sizeof(MPI_Aint) == sizeof(int))
check(extent == MPI_UNDEFINED);
else
check(extent == imx4i_true_extent);
MPI_Type_get_true_extent(imx4i_rsz, &lb, &extent);
check(lb == 0);
if (sizeof(MPI_Aint) == sizeof(int))
check(extent == MPI_UNDEFINED);
else
check(extent == imx4i_true_extent);
/* MPI_Type_get_true_extent_x */
MPI_Type_get_true_extent_x(imax_contig, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == INT_MAX);
MPI_Type_get_true_extent_x(four_ints, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == 4 * sizeof(int));
MPI_Type_get_true_extent_x(imx4i, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == imx4i_true_extent);
MPI_Type_get_true_extent_x(imx4i_rsz, &lb_x, &extent_x);
check(lb_x == 0);
check(extent_x == imx4i_true_extent);
/* MPI_{Status_set_elements,Get_elements}{,_x} */
/* set simple */
MPI_Status_set_elements(&status, MPI_INT, 10);
MPI_Get_elements(&status, MPI_INT, &elements);
MPI_Get_elements_x(&status, MPI_INT, &elements_x);
MPI_Get_count(&status, MPI_INT, &count);
check(elements == 10);
check(elements_x == 10);
check(count == 10);
/* set_x simple */
MPI_Status_set_elements_x(&status, MPI_INT, 10);
MPI_Get_elements(&status, MPI_INT, &elements);
MPI_Get_elements_x(&status, MPI_INT, &elements_x);
MPI_Get_count(&status, MPI_INT, &count);
check(elements == 10);
check(elements_x == 10);
check(count == 10);
/* Sets elements corresponding to count=1 of the given MPI datatype, using
* set_elements and set_elements_x. Checks expected values are returned by
* get_elements, get_elements_x, and get_count (including MPI_UNDEFINED
* clipping) */
#define check_set_elements(type_, elts_) \
do { \
elements = elements_x = count = 0xfeedface; \
/* can't use legacy "set" for large element counts */ \
if ((elts_) <= INT_MAX) { \
MPI_Status_set_elements(&status, (type_), 1); \
MPI_Get_elements(&status, (type_), &elements); \
MPI_Get_elements_x(&status, (type_), &elements_x); \
MPI_Get_count(&status, (type_), &count); \
check(elements == (elts_)); \
check(elements_x == (elts_)); \
check(count == 1); \
} \
\
elements = elements_x = count = 0xfeedface; \
MPI_Status_set_elements_x(&status, (type_), 1); \
MPI_Get_elements(&status, (type_), &elements); \
MPI_Get_elements_x(&status, (type_), &elements_x); \
MPI_Get_count(&status, (type_), &count); \
if ((elts_) > INT_MAX) { \
check(elements == MPI_UNDEFINED); \
} \
else { \
check(elements == (elts_)); \
} \
check(elements_x == (elts_)); \
check(count == 1); \
} while (0) \
check_set_elements(imax_contig, INT_MAX);
check_set_elements(four_ints, 4);
check_set_elements(imx4i, 4LL * (INT_MAX / 2));
check_set_elements(imx4i_rsz, 4LL * (INT_MAX / 2));
epilogue:
if (imax_contig != MPI_DATATYPE_NULL)
MPI_Type_free(&imax_contig);
if (four_ints != MPI_DATATYPE_NULL)
MPI_Type_free(&four_ints);
if (imx4i != MPI_DATATYPE_NULL)
MPI_Type_free(&imx4i);
if (imx4i_rsz != MPI_DATATYPE_NULL)
MPI_Type_free(&imx4i_rsz);
MTest_Finalize(errs);
return MTestReturnValue(errs);
}
|
387398.c | #include <stdio.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/ether.h>
#include <linux/if_packet.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#define PORT 31415
unsigned char asc2nibble(char c) {
if ((c >= '0') && (c <= '9'))
return c - '0';
if ((c >= 'A') && (c <= 'F'))
return c - 'A' + 10;
if ((c >= 'a') && (c <= 'f'))
return c - 'a' + 10;
return 0x0F; // error
}
int main(int argc, char const *argv[])
{
int server_fd, server_socket, valread;
struct sockaddr_in serveraddr;
int opt = 1;
int addrlen = sizeof(serveraddr);
char buffer[32] = {0};
int can_fd;
struct sockaddr_can canaddr;
struct can_filter rfilter[1];
struct ifreq canifr;
// Creating socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// Forcefully attaching socket to the port 31415
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt");
exit(EXIT_FAILURE);
}
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = INADDR_ANY;
serveraddr.sin_port = htons(PORT);
// Forcefully attaching socket to the port 31415
if (bind(server_fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))<0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
if ((server_socket = accept(server_fd, (struct sockaddr *)&serveraddr, (socklen_t*)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}
// Setup CAN socket
if ((can_fd = socket(PF_CAN, SOCK_RAW, CAN_RAW)) == 0) {
perror("cansocket failed");
exit(EXIT_FAILURE);
}
strcpy(canifr.ifr_name, "can0");
ioctl(can_fd, SIOCGIFINDEX, &canifr);
canaddr.can_family = AF_CAN;
canaddr.can_ifindex = canifr.ifr_ifindex;
if (bind(can_fd, (struct sockaddr *)&canaddr, sizeof(canaddr)) < 0) {
perror("canNOT bind");
exit(EXIT_FAILURE);
}
// Only receive responses on $7e8
rfilter[0].can_id = 0x7e8;
rfilter[0].can_mask = CAN_SFF_MASK;
setsockopt(can_fd, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));
while (1) {
valread = read(server_socket, buffer, 32);
//printf("Received: %s\n", buffer);
char candata[32] = {0};
strncat(candata, buffer, 16);
struct can_frame frame;
frame.can_id = 0x7df; // Diagnostic arbitration id
int i;
unsigned char tmp;
for (i = 0; i < 8; i++) {
if ((tmp = asc2nibble(candata[2*i])) > 0x0F)
return -3;
frame.data[i] = (tmp << 4);
if ((tmp = asc2nibble(candata[2*i+1])) > 0x0F)
return -2;
frame.data[i] |= tmp;
}
frame.can_dlc = i;
int nbytes = write(can_fd, &frame, sizeof(struct can_frame));
printf("Wrote %s to the bus (%d).\n", candata, nbytes);
int awaiting_data = 1;
int isotp_size = -1; // Used to store the size of the data, if it's an ISO-TP response.
int frames_received = 0;
while (awaiting_data) {
nbytes = read(can_fd, &frame, sizeof(struct can_frame));
char response[32] = {0};
// Write bytes to hex in response
for (i=0; i<8 && i<nbytes; i++) {
sprintf(&response[i*2], "%02x", frame.data[i]);
}
printf("Read %s from the bus (First byte is %d raw).\n", response, frame.data[0]);
// Send response to client
send(server_socket, response, strlen(response), 0);
// Assume we're not awaiting data, but correct this below if needed.
awaiting_data = 0;
// If it's ISO-TP, we need to save the size if it's the first frame.
if ((frame.data[0] >> 4) == 1) {
isotp_size = (frame.data[0] & 0xF) << 8 | frame.data[1];
isotp_size -= 6;
// Converts bytes to frames.
if (isotp_size % 7 == 0) {
isotp_size /= 7;
} else {
isotp_size /= 7;
isotp_size += 1;
}
printf("We've got ISO-TP on our hands... hold on tight. Expecting %d frames.\n", isotp_size);
}
// If it's ISO-TP, we need to keep reading if it's not the last consecutive frame
if (frames_received++ < isotp_size) {
awaiting_data = 1;
// Send a flow control frame that basically says send everything w/o flow control. (https://en.wikipedia.org/wiki/ISO_15765-2)
struct can_frame flowframe;
flowframe.can_id = 0x7e8 - 8; // Diagnostic arbitration response id
flowframe.data[0] = 0b00110000; // This is a flow control message, continue to send.
flowframe.data[1] = 0; // Don't delay.
flowframe.data[2] = 10; // Wait 10 ms per frame
flowframe.can_dlc = 8;
write(can_fd, &flowframe, sizeof(struct can_frame));
printf("Sent that flow frame.\n");
}
}
}
return 0;
}
|
17258.c | #include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include "runtime/alloc.h"
#include "runtime/atomic.h"
#include "runtime/subtree.h"
#include "runtime/length.h"
#include "runtime/language.h"
#include "runtime/error_costs.h"
#include <stddef.h>
typedef struct {
Length start;
Length old_end;
Length new_end;
} Edit;
TSStateId TS_TREE_STATE_NONE = USHRT_MAX;
#ifdef TREE_SITTER_TEST
#define TS_MAX_INLINE_TREE_LENGTH 2
#define TS_MAX_TREE_POOL_SIZE 0
#else
#define TS_MAX_INLINE_TREE_LENGTH UINT8_MAX
#define TS_MAX_TREE_POOL_SIZE 32
#endif
static const ExternalScannerState empty_state = {.length = 0, .short_data = {0}};
// ExternalScannerState
void ts_external_scanner_state_init(ExternalScannerState *self, const char *data, unsigned length) {
self->length = length;
if (length > sizeof(self->short_data)) {
self->long_data = ts_malloc(length);
memcpy(self->long_data, data, length);
} else {
memcpy(self->short_data, data, length);
}
}
ExternalScannerState ts_external_scanner_state_copy(const ExternalScannerState *self) {
ExternalScannerState result = *self;
if (self->length > sizeof(self->short_data)) {
result.long_data = ts_malloc(self->length);
memcpy(result.long_data, self->long_data, self->length);
}
return result;
}
void ts_external_scanner_state_delete(ExternalScannerState *self) {
if (self->length > sizeof(self->short_data)) {
ts_free(self->long_data);
}
}
const char *ts_external_scanner_state_data(const ExternalScannerState *self) {
if (self->length > sizeof(self->short_data)) {
return self->long_data;
} else {
return self->short_data;
}
}
bool ts_external_scanner_state_eq(const ExternalScannerState *a, const ExternalScannerState *b) {
return a == b || (
a->length == b->length &&
!memcmp(ts_external_scanner_state_data(a), ts_external_scanner_state_data(b), a->length)
);
}
// SubtreeArray
void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest) {
dest->size = self.size;
dest->capacity = self.capacity;
dest->contents = self.contents;
if (self.capacity > 0) {
dest->contents = ts_calloc(self.capacity, sizeof(Subtree));
memcpy(dest->contents, self.contents, self.size * sizeof(Subtree));
for (uint32_t i = 0; i < self.size; i++) {
ts_subtree_retain(dest->contents[i]);
}
}
}
void ts_subtree_array_delete(SubtreePool *pool, SubtreeArray *self) {
for (uint32_t i = 0; i < self->size; i++) {
ts_subtree_release(pool, self->contents[i]);
}
array_delete(self);
}
SubtreeArray ts_subtree_array_remove_trailing_extras(SubtreeArray *self) {
SubtreeArray result = array_new();
uint32_t i = self->size - 1;
for (; i + 1 > 0; i--) {
Subtree child = self->contents[i];
if (!ts_subtree_extra(child)) break;
array_push(&result, child);
}
self->size = i + 1;
ts_subtree_array_reverse(&result);
return result;
}
void ts_subtree_array_reverse(SubtreeArray *self) {
for (uint32_t i = 0, limit = self->size / 2; i < limit; i++) {
size_t reverse_index = self->size - 1 - i;
Subtree swap = self->contents[i];
self->contents[i] = self->contents[reverse_index];
self->contents[reverse_index] = swap;
}
}
// SubtreePool
SubtreePool ts_subtree_pool_new(uint32_t capacity) {
SubtreePool self = {array_new(), array_new()};
array_reserve(&self.free_trees, capacity);
return self;
}
void ts_subtree_pool_delete(SubtreePool *self) {
if (self->free_trees.contents) {
for (unsigned i = 0; i < self->free_trees.size; i++) {
ts_free(self->free_trees.contents[i].ptr);
}
array_delete(&self->free_trees);
}
if (self->tree_stack.contents) array_delete(&self->tree_stack);
}
static SubtreeHeapData *ts_subtree_pool_allocate(SubtreePool *self) {
if (self->free_trees.size > 0) {
return array_pop(&self->free_trees).ptr;
} else {
return ts_malloc(sizeof(SubtreeHeapData));
}
}
static void ts_subtree_pool_free(SubtreePool *self, SubtreeHeapData *tree) {
if (self->free_trees.capacity > 0 && self->free_trees.size + 1 <= TS_MAX_TREE_POOL_SIZE) {
array_push(&self->free_trees, (MutableSubtree) {.ptr = tree});
} else {
ts_free(tree);
}
}
// Subtree
static inline bool ts_subtree_can_inline(Length padding, Length size, uint32_t lookahead_bytes) {
return
padding.bytes < TS_MAX_INLINE_TREE_LENGTH &&
padding.extent.row < 16 &&
padding.extent.column < TS_MAX_INLINE_TREE_LENGTH &&
size.extent.row == 0 &&
size.extent.column < TS_MAX_INLINE_TREE_LENGTH &&
lookahead_bytes < 16;
}
Subtree ts_subtree_new_leaf(
SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
uint32_t lookahead_bytes, TSStateId parse_state, bool has_external_tokens,
bool is_keyword, const TSLanguage *language
) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool extra = symbol == ts_builtin_sym_end;
bool is_inline = (
symbol <= UINT8_MAX &&
!has_external_tokens &&
ts_subtree_can_inline(padding, size, lookahead_bytes)
);
if (is_inline) {
return (Subtree) {{
.parse_state = parse_state,
.symbol = symbol,
.padding_bytes = padding.bytes,
.padding_rows = padding.extent.row,
.padding_columns = padding.extent.column,
.size_bytes = size.bytes,
.lookahead_bytes = lookahead_bytes,
.visible = metadata.visible,
.named = metadata.named,
.extra = extra,
.has_changes = false,
.is_missing = false,
.is_keyword = is_keyword,
.is_inline = true,
}};
} else {
SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
*data = (SubtreeHeapData) {
.ref_count = 1,
.padding = padding,
.size = size,
.lookahead_bytes = lookahead_bytes,
.error_cost = 0,
.child_count = 0,
.symbol = symbol,
.parse_state = parse_state,
.visible = metadata.visible,
.named = metadata.named,
.extra = extra,
.fragile_left = false,
.fragile_right = false,
.has_changes = false,
.has_external_tokens = has_external_tokens,
.is_missing = false,
.is_keyword = is_keyword,
.first_leaf = {.symbol = 0, .parse_state = 0},
};
return (Subtree) {.ptr = data};
}
}
Subtree ts_subtree_new_error(
SubtreePool *pool, int32_t lookahead_char, Length padding, Length size,
uint32_t bytes_scanned, TSStateId parse_state, const TSLanguage *language
) {
Subtree result = ts_subtree_new_leaf(
pool, ts_builtin_sym_error, padding, size, bytes_scanned,
parse_state, false, false, language
);
SubtreeHeapData *data = (SubtreeHeapData *)result.ptr;
data->fragile_left = true;
data->fragile_right = true;
data->lookahead_char = lookahead_char;
return result;
}
MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self) {
if (self.data.is_inline) return (MutableSubtree) {self.data};
if (self.ptr->ref_count == 1) return ts_subtree_to_mut_unsafe(self);
SubtreeHeapData *result = ts_subtree_pool_allocate(pool);
memcpy(result, self.ptr, sizeof(SubtreeHeapData));
if (result->child_count > 0) {
result->children = ts_calloc(self.ptr->child_count, sizeof(Subtree));
memcpy(result->children, self.ptr->children, result->child_count * sizeof(Subtree));
for (uint32_t i = 0; i < result->child_count; i++) {
ts_subtree_retain(result->children[i]);
}
} else if (result->has_external_tokens) {
result->external_scanner_state = ts_external_scanner_state_copy(&self.ptr->external_scanner_state);
}
result->ref_count = 1;
ts_subtree_release(pool, self);
return (MutableSubtree) {.ptr = result};
}
static void ts_subtree__compress(MutableSubtree self, unsigned count, const TSLanguage *language,
MutableSubtreeArray *stack) {
unsigned initial_stack_size = stack->size;
MutableSubtree tree = self;
TSSymbol symbol = tree.ptr->symbol;
for (unsigned i = 0; i < count; i++) {
if (tree.ptr->ref_count > 1 || tree.ptr->child_count < 2) break;
MutableSubtree child = ts_subtree_to_mut_unsafe(tree.ptr->children[0]);
if (
child.data.is_inline ||
child.ptr->child_count < 2 ||
child.ptr->ref_count > 1 ||
child.ptr->symbol != symbol
) break;
MutableSubtree grandchild = ts_subtree_to_mut_unsafe(child.ptr->children[0]);
if (
grandchild.data.is_inline ||
grandchild.ptr->child_count < 2 ||
grandchild.ptr->ref_count > 1 ||
grandchild.ptr->symbol != symbol
) break;
tree.ptr->children[0] = ts_subtree_from_mut(grandchild);
child.ptr->children[0] = grandchild.ptr->children[grandchild.ptr->child_count - 1];
grandchild.ptr->children[grandchild.ptr->child_count - 1] = ts_subtree_from_mut(child);
array_push(stack, tree);
tree = grandchild;
}
while (stack->size > initial_stack_size) {
tree = array_pop(stack);
MutableSubtree child = ts_subtree_to_mut_unsafe(tree.ptr->children[0]);
MutableSubtree grandchild = ts_subtree_to_mut_unsafe(child.ptr->children[child.ptr->child_count - 1]);
ts_subtree_set_children(grandchild, grandchild.ptr->children, grandchild.ptr->child_count, language);
ts_subtree_set_children(child, child.ptr->children, child.ptr->child_count, language);
ts_subtree_set_children(tree, tree.ptr->children, tree.ptr->child_count, language);
}
}
void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language) {
array_clear(&pool->tree_stack);
if (ts_subtree_child_count(self) > 0 && self.ptr->ref_count == 1) {
array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self));
}
while (pool->tree_stack.size > 0) {
MutableSubtree tree = array_pop(&pool->tree_stack);
if (tree.ptr->repeat_depth > 0) {
Subtree child1 = tree.ptr->children[0];
Subtree child2 = tree.ptr->children[tree.ptr->child_count - 1];
if (
ts_subtree_child_count(child1) > 0 &&
ts_subtree_child_count(child2) > 0 &&
child1.ptr->repeat_depth > child2.ptr->repeat_depth
) {
unsigned n = child1.ptr->repeat_depth - child2.ptr->repeat_depth;
for (unsigned i = n / 2; i > 0; i /= 2) {
ts_subtree__compress(tree, i, language, &pool->tree_stack);
n -= i;
}
}
}
for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
Subtree child = tree.ptr->children[i];
if (ts_subtree_child_count(child) > 0 && child.ptr->ref_count == 1) {
array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child));
}
}
}
}
static inline uint32_t ts_subtree_repeat_depth(Subtree self) {
return ts_subtree_child_count(self) ? self.ptr->repeat_depth : 0;
}
void ts_subtree_set_children(
MutableSubtree self, Subtree *children, uint32_t child_count, const TSLanguage *language
) {
assert(!self.data.is_inline);
if (self.ptr->child_count > 0 && children != self.ptr->children) {
ts_free(self.ptr->children);
}
self.ptr->child_count = child_count;
self.ptr->children = children;
self.ptr->named_child_count = 0;
self.ptr->visible_child_count = 0;
self.ptr->error_cost = 0;
self.ptr->repeat_depth = 0;
self.ptr->node_count = 1;
self.ptr->has_external_tokens = false;
self.ptr->dynamic_precedence = 0;
uint32_t non_extra_index = 0;
const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->alias_sequence_id);
uint32_t lookahead_end_byte = 0;
for (uint32_t i = 0; i < self.ptr->child_count; i++) {
Subtree child = self.ptr->children[i];
if (i == 0) {
self.ptr->padding = ts_subtree_padding(child);
self.ptr->size = ts_subtree_size(child);
} else {
self.ptr->size = length_add(self.ptr->size, ts_subtree_total_size(child));
}
uint32_t child_lookahead_end_byte =
self.ptr->padding.bytes +
self.ptr->size.bytes +
ts_subtree_lookahead_bytes(child);
if (child_lookahead_end_byte > lookahead_end_byte) lookahead_end_byte = child_lookahead_end_byte;
if (ts_subtree_symbol(child) != ts_builtin_sym_error_repeat) {
self.ptr->error_cost += ts_subtree_error_cost(child);
}
self.ptr->dynamic_precedence += ts_subtree_dynamic_precedence(child);
self.ptr->node_count += ts_subtree_node_count(child);
if (alias_sequence && alias_sequence[non_extra_index] != 0 && !ts_subtree_extra(child)) {
self.ptr->visible_child_count++;
if (ts_language_symbol_metadata(language, alias_sequence[non_extra_index]).named) {
self.ptr->named_child_count++;
}
} else if (ts_subtree_visible(child)) {
self.ptr->visible_child_count++;
if (ts_subtree_named(child)) self.ptr->named_child_count++;
} else if (ts_subtree_child_count(child) > 0) {
self.ptr->visible_child_count += child.ptr->visible_child_count;
self.ptr->named_child_count += child.ptr->named_child_count;
}
if (ts_subtree_has_external_tokens(child)) self.ptr->has_external_tokens = true;
if (ts_subtree_is_error(child)) {
self.ptr->fragile_left = self.ptr->fragile_right = true;
self.ptr->parse_state = TS_TREE_STATE_NONE;
}
if (!ts_subtree_extra(child)) non_extra_index++;
}
self.ptr->lookahead_bytes = lookahead_end_byte - self.ptr->size.bytes - self.ptr->padding.bytes;
if (self.ptr->symbol == ts_builtin_sym_error || self.ptr->symbol == ts_builtin_sym_error_repeat) {
self.ptr->error_cost +=
ERROR_COST_PER_RECOVERY +
ERROR_COST_PER_SKIPPED_CHAR * self.ptr->size.bytes +
ERROR_COST_PER_SKIPPED_LINE * self.ptr->size.extent.row;
for (uint32_t i = 0; i < self.ptr->child_count; i++) {
Subtree child = self.ptr->children[i];
uint32_t grandchild_count = ts_subtree_child_count(child);
if (ts_subtree_extra(child)) continue;
if (ts_subtree_is_error(child) && grandchild_count == 0) continue;
if (ts_subtree_visible(child)) {
self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE;
} else if (grandchild_count > 0) {
self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE * child.ptr->visible_child_count;
}
}
}
if (self.ptr->child_count > 0) {
Subtree first_child = self.ptr->children[0];
Subtree last_child = self.ptr->children[self.ptr->child_count - 1];
self.ptr->first_leaf.symbol = ts_subtree_leaf_symbol(first_child);
self.ptr->first_leaf.parse_state = ts_subtree_leaf_parse_state(first_child);
if (ts_subtree_fragile_left(first_child)) self.ptr->fragile_left = true;
if (ts_subtree_fragile_right(last_child)) self.ptr->fragile_right = true;
if (
self.ptr->child_count >= 2 &&
!self.ptr->visible &&
!self.ptr->named &&
ts_subtree_symbol(first_child) == self.ptr->symbol
) {
if (ts_subtree_repeat_depth(first_child) > ts_subtree_repeat_depth(last_child)) {
self.ptr->repeat_depth = ts_subtree_repeat_depth(first_child) + 1;
} else {
self.ptr->repeat_depth = ts_subtree_repeat_depth(last_child) + 1;
}
}
}
}
MutableSubtree ts_subtree_new_node(SubtreePool *pool, TSSymbol symbol,
SubtreeArray *children, unsigned alias_sequence_id,
const TSLanguage *language) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat;
SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
*data = (SubtreeHeapData) {
.ref_count = 1,
.symbol = symbol,
.alias_sequence_id = alias_sequence_id,
.visible = metadata.visible,
.named = metadata.named,
.has_changes = false,
.fragile_left = fragile,
.fragile_right = fragile,
.is_keyword = false,
.node_count = 0,
.first_leaf = {.symbol = 0, .parse_state = 0},
};
MutableSubtree result = {.ptr = data};
ts_subtree_set_children(result, children->contents, children->size, language);
return result;
}
Subtree ts_subtree_new_error_node(SubtreePool *pool, SubtreeArray *children,
bool extra, const TSLanguage *language) {
MutableSubtree result = ts_subtree_new_node(
pool, ts_builtin_sym_error, children, 0, language
);
result.ptr->extra = extra;
return ts_subtree_from_mut(result);
}
Subtree ts_subtree_new_missing_leaf(SubtreePool *pool, TSSymbol symbol, Length padding,
const TSLanguage *language) {
Subtree result = ts_subtree_new_leaf(
pool, symbol, padding, length_zero(), 0,
0, false, false, language
);
if (result.data.is_inline) {
result.data.is_missing = true;
} else {
((SubtreeHeapData *)result.ptr)->is_missing = true;
}
return result;
}
void ts_subtree_retain(Subtree self) {
if (self.data.is_inline) return;
assert(self.ptr->ref_count > 0);
atomic_inc((volatile uint32_t *)&self.ptr->ref_count);
assert(self.ptr->ref_count != 0);
}
void ts_subtree_release(SubtreePool *pool, Subtree self) {
if (self.data.is_inline) return;
array_clear(&pool->tree_stack);
assert(self.ptr->ref_count > 0);
if (atomic_dec((volatile uint32_t *)&self.ptr->ref_count) == 0) {
array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self));
}
while (pool->tree_stack.size > 0) {
MutableSubtree tree = array_pop(&pool->tree_stack);
if (tree.ptr->child_count > 0) {
for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
Subtree child = tree.ptr->children[i];
if (child.data.is_inline) continue;
assert(child.ptr->ref_count > 0);
if (atomic_dec((volatile uint32_t *)&child.ptr->ref_count) == 0) {
array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child));
}
}
ts_free(tree.ptr->children);
} else if (tree.ptr->has_external_tokens) {
ts_external_scanner_state_delete(&tree.ptr->external_scanner_state);
}
ts_subtree_pool_free(pool, tree.ptr);
}
}
bool ts_subtree_eq(Subtree self, Subtree other) {
if (self.data.is_inline || other.data.is_inline) {
return memcmp(&self, &other, sizeof(SubtreeInlineData)) == 0;
}
if (self.ptr) {
if (!other.ptr) return false;
} else {
return !other.ptr;
}
if (self.ptr->symbol != other.ptr->symbol) return false;
if (self.ptr->visible != other.ptr->visible) return false;
if (self.ptr->named != other.ptr->named) return false;
if (self.ptr->padding.bytes != other.ptr->padding.bytes) return false;
if (self.ptr->size.bytes != other.ptr->size.bytes) return false;
if (self.ptr->symbol == ts_builtin_sym_error) return self.ptr->lookahead_char == other.ptr->lookahead_char;
if (self.ptr->child_count != other.ptr->child_count) return false;
if (self.ptr->child_count > 0) {
if (self.ptr->visible_child_count != other.ptr->visible_child_count) return false;
if (self.ptr->named_child_count != other.ptr->named_child_count) return false;
for (uint32_t i = 0; i < self.ptr->child_count; i++) {
if (!ts_subtree_eq(self.ptr->children[i], other.ptr->children[i])) {
return false;
}
}
}
return true;
}
int ts_subtree_compare(Subtree left, Subtree right) {
if (ts_subtree_symbol(left) < ts_subtree_symbol(right)) return -1;
if (ts_subtree_symbol(right) < ts_subtree_symbol(left)) return 1;
if (ts_subtree_child_count(left) < ts_subtree_child_count(right)) return -1;
if (ts_subtree_child_count(right) < ts_subtree_child_count(left)) return 1;
for (uint32_t i = 0, n = ts_subtree_child_count(left); i < n; i++) {
Subtree left_child = left.ptr->children[i];
Subtree right_child = right.ptr->children[i];
switch (ts_subtree_compare(left_child, right_child)) {
case -1: return -1;
case 1: return 1;
default: break;
}
}
return 0;
}
static inline void ts_subtree_set_has_changes(MutableSubtree *self) {
if (self->data.is_inline) {
self->data.has_changes = true;
} else {
self->ptr->has_changes = true;
}
}
Subtree ts_subtree_edit(Subtree self, const TSInputEdit *edit, SubtreePool *pool) {
typedef struct {
Subtree *tree;
Edit edit;
} StackEntry;
Array(StackEntry) stack = array_new();
array_push(&stack, ((StackEntry) {
.tree = &self,
.edit = (Edit) {
.start = {edit->start_byte, edit->start_point},
.old_end = {edit->old_end_byte, edit->old_end_point},
.new_end = {edit->new_end_byte, edit->new_end_point},
},
}));
while (stack.size) {
StackEntry entry = array_pop(&stack);
Edit edit = entry.edit;
bool is_noop = edit.old_end.bytes == edit.start.bytes && edit.new_end.bytes == edit.start.bytes;
bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes;
Length size = ts_subtree_size(*entry.tree);
Length padding = ts_subtree_padding(*entry.tree);
uint32_t lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree);
uint32_t end_byte = padding.bytes + size.bytes + lookahead_bytes;
if (edit.start.bytes > end_byte || (is_noop && edit.start.bytes == end_byte)) continue;
// If the edit is entirely within the space before this subtree, then shift this
// subtree over according to the edit without changing its size.
if (edit.old_end.bytes <= padding.bytes) {
padding = length_add(edit.new_end, length_sub(padding, edit.old_end));
}
// If the edit starts in the space before this subtree and extends into this subtree,
// shrink the subtree's content to compensate for the change in the space before it.
else if (edit.start.bytes < padding.bytes) {
size = length_sub(size, length_sub(edit.old_end, padding));
padding = edit.new_end;
}
// If the edit is a pure insertion right at the start of the subtree,
// shift the subtree over according to the insertion.
else if (edit.start.bytes == padding.bytes && is_pure_insertion) {
padding = edit.new_end;
}
// If the edit is within this subtree, resize the subtree to reflect the edit.
else {
uint32_t total_bytes = padding.bytes + size.bytes;
if (edit.start.bytes < total_bytes ||
(edit.start.bytes == total_bytes && is_pure_insertion)) {
size = length_add(
length_sub(edit.new_end, padding),
length_sub(size, length_sub(edit.old_end, padding))
);
}
}
MutableSubtree result = ts_subtree_make_mut(pool, *entry.tree);
if (result.data.is_inline) {
if (ts_subtree_can_inline(padding, size, lookahead_bytes)) {
result.data.padding_bytes = padding.bytes;
result.data.padding_rows = padding.extent.row;
result.data.padding_columns = padding.extent.column;
result.data.size_bytes = size.bytes;
} else {
SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
data->ref_count = 1;
data->padding = padding;
data->size = size;
data->lookahead_bytes = lookahead_bytes;
data->error_cost = 0;
data->child_count = 0;
data->symbol = result.data.symbol;
data->parse_state = result.data.parse_state;
data->visible = result.data.visible;
data->named = result.data.named;
data->extra = result.data.extra;
data->fragile_left = false;
data->fragile_right = false;
data->has_changes = false;
data->has_external_tokens = false;
data->is_missing = result.data.is_missing;
data->is_keyword = result.data.is_keyword;
result.ptr = data;
}
} else {
result.ptr->padding = padding;
result.ptr->size = size;
}
ts_subtree_set_has_changes(&result);
*entry.tree = ts_subtree_from_mut(result);
Length child_left, child_right = length_zero();
for (uint32_t i = 0, n = ts_subtree_child_count(*entry.tree); i < n; i++) {
Subtree *child = &result.ptr->children[i];
Length child_size = ts_subtree_total_size(*child);
child_left = child_right;
child_right = length_add(child_left, child_size);
// If this child ends before the edit, it is not affected.
if (child_right.bytes + ts_subtree_lookahead_bytes(*child) < edit.start.bytes) continue;
// If this child starts after the edit, then we're done processing children.
if (child_left.bytes > edit.old_end.bytes ||
(child_left.bytes == edit.old_end.bytes && child_size.bytes > 0 && i > 0)) break;
// Transform edit into the child's coordinate space.
Edit child_edit = {
.start = length_sub(edit.start, child_left),
.old_end = length_sub(edit.old_end, child_left),
.new_end = length_sub(edit.new_end, child_left),
};
// Clamp child_edit to the child's bounds.
if (edit.start.bytes < child_left.bytes) child_edit.start = length_zero();
if (edit.old_end.bytes < child_left.bytes) child_edit.old_end = length_zero();
if (edit.new_end.bytes < child_left.bytes) child_edit.new_end = length_zero();
if (edit.old_end.bytes > child_right.bytes) child_edit.old_end = child_size;
// Interpret all inserted text as applying to the *first* child that touches the edit.
// Subsequent children are only never have any text inserted into them; they are only
// shrunk to compensate for the edit.
if (child_right.bytes > edit.start.bytes ||
(child_right.bytes == edit.start.bytes && is_pure_insertion)) {
edit.new_end = edit.start;
}
// Children that occur before the edit are not reshaped by the edit.
else {
child_edit.old_end = child_edit.start;
child_edit.new_end = child_edit.start;
}
// Queue processing of this child's subtree.
array_push(&stack, ((StackEntry) {
.tree = child,
.edit = child_edit,
}));
}
}
array_delete(&stack);
return self;
}
Subtree ts_subtree_last_external_token(Subtree tree) {
if (!ts_subtree_has_external_tokens(tree)) return NULL_SUBTREE;
while (tree.ptr->child_count > 0) {
for (uint32_t i = tree.ptr->child_count - 1; i + 1 > 0; i--) {
Subtree child = tree.ptr->children[i];
if (ts_subtree_has_external_tokens(child)) {
tree = child;
break;
}
}
}
return tree;
}
static size_t ts_subtree__write_char_to_string(char *s, size_t n, int32_t c) {
if (c == 0)
return snprintf(s, n, "EOF");
if (c == -1)
return snprintf(s, n, "INVALID");
else if (c == '\n')
return snprintf(s, n, "'\\n'");
else if (c == '\t')
return snprintf(s, n, "'\\t'");
else if (c == '\r')
return snprintf(s, n, "'\\r'");
else if (0 < c && c < 128 && isprint(c))
return snprintf(s, n, "'%c'", c);
else
return snprintf(s, n, "%d", c);
}
static void ts_subtree__write_dot_string(FILE *f, const char *string) {
for (const char *c = string; *c; c++) {
if (*c == '"') {
fputs("\\\"", f);
} else if (*c == '\n') {
fputs("\\n", f);
} else {
fputc(*c, f);
}
}
}
static size_t ts_subtree__write_to_string(Subtree self, char *string, size_t limit,
const TSLanguage *language, bool is_root,
bool include_all, TSSymbol alias_symbol,
bool alias_is_named) {
if (!self.ptr) return snprintf(string, limit, "(NULL)");
char *cursor = string;
char **writer = (limit > 0) ? &cursor : &string;
bool visible =
include_all ||
is_root ||
ts_subtree_missing(self) ||
(ts_subtree_visible(self) && ts_subtree_named(self)) ||
alias_is_named;
if (visible && !is_root) {
cursor += snprintf(*writer, limit, " ");
}
if (visible) {
if (ts_subtree_is_error(self) && ts_subtree_child_count(self) == 0 && self.ptr->size.bytes > 0) {
cursor += snprintf(*writer, limit, "(UNEXPECTED ");
cursor += ts_subtree__write_char_to_string(*writer, limit, self.ptr->lookahead_char);
} else if (ts_subtree_missing(self)) {
cursor += snprintf(*writer, limit, "(MISSING");
} else {
TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
const char *symbol_name = ts_language_symbol_name(language, symbol);
cursor += snprintf(*writer, limit, "(%s", symbol_name);
}
}
if (ts_subtree_child_count(self)) {
const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->alias_sequence_id);
uint32_t structural_child_index = 0;
for (uint32_t i = 0; i < self.ptr->child_count; i++) {
Subtree child = self.ptr->children[i];
if (ts_subtree_extra(child)) {
cursor += ts_subtree__write_to_string(
child, *writer, limit,
language, false, include_all,
0, false
);
} else {
TSSymbol alias_symbol = alias_sequence ? alias_sequence[structural_child_index] : 0;
cursor += ts_subtree__write_to_string(
child, *writer, limit,
language, false, include_all,
alias_symbol,
alias_symbol ? ts_language_symbol_metadata(language, alias_symbol).named : false
);
structural_child_index++;
}
}
}
if (visible) cursor += snprintf(*writer, limit, ")");
return cursor - string;
}
char *ts_subtree_string(Subtree self, const TSLanguage *language, bool include_all) {
char scratch_string[1];
size_t size = ts_subtree__write_to_string(
self, scratch_string, 0,
language, true,
include_all, 0, false
) + 1;
char *result = ts_malloc(size * sizeof(char));
ts_subtree__write_to_string(self, result, size, language, true, include_all, 0, false);
return result;
}
void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
const TSLanguage *language, TSSymbol alias_symbol,
FILE *f) {
TSSymbol subtree_symbol = ts_subtree_symbol(*self);
TSSymbol symbol = alias_symbol ? alias_symbol : subtree_symbol;
uint32_t end_offset = start_offset + ts_subtree_total_bytes(*self);
fprintf(f, "tree_%p [label=\"", self);
ts_subtree__write_dot_string(f, ts_language_symbol_name(language, symbol));
fprintf(f, "\"");
if (ts_subtree_child_count(*self) == 0) fprintf(f, ", shape=plaintext");
if (ts_subtree_extra(*self)) fprintf(f, ", fontcolor=gray");
fprintf(f, ", tooltip=\""
"range: %u - %u\n"
"state: %d\n"
"error-cost: %u\n"
"has-changes: %u\n"
"repeat-depth: %u\n"
"lookahead-bytes: %u\"]\n",
start_offset, end_offset,
ts_subtree_parse_state(*self),
ts_subtree_error_cost(*self),
ts_subtree_has_changes(*self),
ts_subtree_repeat_depth(*self),
ts_subtree_lookahead_bytes(*self)
);
uint32_t child_start_offset = start_offset;
uint32_t structural_child_index = 0;
const TSSymbol *alias_sequence = ts_language_alias_sequence(
language,
ts_subtree_alias_sequence_id(*self)
);
for (uint32_t i = 0, n = ts_subtree_child_count(*self); i < n; i++) {
const Subtree *child = &self->ptr->children[i];
if (ts_subtree_extra(*child)) {
ts_subtree__print_dot_graph(child, child_start_offset, language, 0, f);
} else {
TSSymbol alias_symbol = alias_sequence ? alias_sequence[structural_child_index] : 0;
ts_subtree__print_dot_graph(child, child_start_offset, language, alias_symbol, f);
structural_child_index++;
}
fprintf(f, "tree_%p -> tree_%p [tooltip=%u]\n", self, child, i);
child_start_offset += ts_subtree_total_bytes(*child);
}
}
void ts_subtree_print_dot_graph(Subtree self, const TSLanguage *language, FILE *f) {
fprintf(f, "digraph tree {\n");
fprintf(f, "edge [arrowhead=none]\n");
ts_subtree__print_dot_graph(&self, 0, language, 0, f);
fprintf(f, "}\n");
}
bool ts_subtree_external_scanner_state_eq(Subtree self, Subtree other) {
const ExternalScannerState *state1 = &empty_state;
const ExternalScannerState *state2 = &empty_state;
if (self.ptr && ts_subtree_has_external_tokens(self) && !self.ptr->child_count) {
state1 = &self.ptr->external_scanner_state;
}
if (other.ptr && ts_subtree_has_external_tokens(other) && !other.ptr->child_count) {
state2 = &other.ptr->external_scanner_state;
}
return ts_external_scanner_state_eq(state1, state2);
}
|
560228.c | /*
* Creation Date: <2004/08/28 18:38:22 greg>
* Time-stamp: <2004/08/28 18:38:22 greg>
*
* <methods.c>
*
* Misc device node methods
*
* Copyright (C) 2004 Greg Watson
*
* Based on MOL specific code which is
*
* Copyright (C) 2003, 2004 Samuel Rydh ([email protected])
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2
*
*/
#include "config.h"
#include "libopenbios/bindings.h"
#include "libc/string.h"
#include "pearpc/pearpc.h"
#include "libopenbios/ofmem.h"
/************************************************************************/
/* RTAS (run-time abstraction services) */
/************************************************************************/
#ifdef CONFIG_RTAS
DECLARE_NODE( rtas, INSTALL_OPEN, 0, "+/rtas" );
/* ( physbase -- rtas_callback ) */
static void
rtas_instantiate( void )
{
int physbase = POP();
int s=0x1000, size = (int)of_rtas_end - (int)of_rtas_start;
unsigned long virt;
while( s < size )
s += 0x1000;
virt = ofmem_claim_virt( 0, s, 0x1000 );
ofmem_map( physbase, virt, s, -1 );
memcpy( (char*)virt, of_rtas_start, size );
printk("RTAS instantiated at %08x\n", physbase );
flush_icache_range( (char*)virt, (char*)virt + size );
PUSH( physbase );
}
NODE_METHODS( rtas ) = {
{ "instantiate", rtas_instantiate },
{ "instantiate-rtas", rtas_instantiate },
};
#endif
/************************************************************************/
/* stdout */
/************************************************************************/
DECLARE_NODE( video_stdout, INSTALL_OPEN, 0, "Tdisplay" );
/* ( addr len -- actual ) */
static void
stdout_write( void )
{
int len = POP();
char *addr = (char*)POP();
printk( "%s", s );
//vfd_draw_str( s );
console_draw_fstr(addr, len);
PUSH( len );
}
NODE_METHODS( video_stdout ) = {
{ "write", stdout_write },
};
/************************************************************************/
/* tty */
/************************************************************************/
DECLARE_NODE( tty, INSTALL_OPEN, 0, "/packages/terminal-emulator" );
/* ( addr len -- actual ) */
static void
tty_read( void )
{
int ch, len = POP();
char *p = (char*)POP();
int ret=0;
if( len > 0 ) {
ret = 1;
ch = getchar();
if( ch >= 0 ) {
*p = ch;
} else {
ret = 0;
}
}
PUSH( ret );
}
/* ( addr len -- actual ) */
static void
tty_write( void )
{
int i, len = POP();
char *p = (char*)POP();
for( i=0; i<len; i++ )
putchar( *p++ );
RET( len );
}
NODE_METHODS( tty ) = {
{ "read", tty_read },
{ "write", tty_write },
};
/************************************************************************/
/* client interface 'quiesce' */
/************************************************************************/
DECLARE_NODE( ciface, 0, 0, "/packages/client-iface" );
/* ( -- ) */
static void
ciface_quiesce( unsigned long args[], unsigned long ret[] )
{
#if 0
unsigned long msr;
/* This seems to be the correct thing to do - but I'm not sure */
asm volatile("mfmsr %0" : "=r" (msr) : );
msr &= ~(MSR_IR | MSR_DR);
asm volatile("mtmsr %0" :: "r" (msr) );
#endif
printk("=============================================================\n\n");
}
/* ( -- ms ) */
static void
ciface_milliseconds( unsigned long args[], unsigned long ret[] )
{
extern unsigned long get_timer_freq();
static unsigned long mticks=0, usecs=0;
unsigned long t;
asm volatile("mftb %0" : "=r" (t) : );
if( mticks )
usecs += get_timer_freq() / 1000000 * ( t-mticks );
mticks = t;
PUSH( usecs/1000 );
}
NODE_METHODS( ciface ) = {
{ "quiesce", ciface_quiesce },
{ "milliseconds", ciface_milliseconds },
};
/************************************************************************/
/* MMU/memory methods */
/************************************************************************/
DECLARE_NODE( memory, INSTALL_OPEN, 0, "/memory" );
DECLARE_NODE( mmu, INSTALL_OPEN, 0, "/cpu@0" );
DECLARE_NODE( mmu_ciface, 0, 0, "/packages/client-iface" );
/* ( phys size align --- base ) */
static void
mem_claim( void )
{
ucell align = POP();
ucell size = POP();
ucell phys = POP();
ucell ret = ofmem_claim_phys( phys, size, align );
if( ret == (ucell)-1 ) {
printk("MEM: claim failure\n");
throw( -13 );
return;
}
PUSH( ret );
}
/* ( phys size --- ) */
static void
mem_release( void )
{
POP(); POP();
}
/* ( phys size align --- base ) */
static void
mmu_claim( void )
{
ucell align = POP();
ucell size = POP();
ucell phys = POP();
ucell ret = ofmem_claim_virt( phys, size, align );
if( ret == -1 ) {
printk("MMU: CLAIM failure\n");
throw( -13 );
return;
}
PUSH( ret );
}
/* ( phys size --- ) */
static void
mmu_release( void )
{
POP(); POP();
}
/* ( phys virt size mode -- [ret???] ) */
static void
mmu_map( void )
{
ucell mode = POP();
ucell size = POP();
ucell virt = POP();
ucell phys = POP();
ucell ret;
/* printk("mmu_map: %x %x %x %x\n", phys, virt, size, mode ); */
ret = ofmem_map( phys, virt, size, mode );
if( ret ) {
printk("MMU: map failure\n");
throw( -13 );
return;
}
}
/* ( virt size -- ) */
static void
mmu_unmap( void )
{
POP(); POP();
}
/* ( virt -- false | phys mode true ) */
static void
mmu_translate( void )
{
ucell mode;
ucell virt = POP();
ucell phys = ofmem_translate( virt, &mode );
if( phys == -1 ) {
PUSH( 0 );
} else {
PUSH( phys );
PUSH( mode );
PUSH( -1 );
}
}
/* ( virt size align -- baseaddr|-1 ) */
static void
ciface_claim( void )
{
ucell align = POP();
ucell size = POP();
ucell virt = POP();
ucell ret = ofmem_claim( virt, size, align );
/* printk("ciface_claim: %08x %08x %x\n", virt, size, align ); */
PUSH( ret );
}
/* ( virt size -- ) */
static void
ciface_release( void )
{
POP();
POP();
}
NODE_METHODS( memory ) = {
{ "claim", mem_claim },
{ "release", mem_release },
};
NODE_METHODS( mmu ) = {
{ "claim", mmu_claim },
{ "release", mmu_release },
{ "map", mmu_map },
{ "unmap", mmu_unmap },
{ "translate", mmu_translate },
};
NODE_METHODS( mmu_ciface ) = {
{ "cif-claim", ciface_claim },
{ "cif-release", ciface_release },
};
/************************************************************************/
/* init */
/************************************************************************/
void
node_methods_init( void )
{
#ifdef CONFIG_RTAS
REGISTER_NODE( rtas );
#endif
REGISTER_NODE( video_stdout );
REGISTER_NODE( ciface );
REGISTER_NODE( memory );
REGISTER_NODE( mmu );
REGISTER_NODE( mmu_ciface );
REGISTER_NODE( tty );
}
|
248265.c | /*
* Copyright(c) 2015-2018 Intel Corporation.
*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* GPL LICENSE SUMMARY
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* BSD LICENSE
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/ratelimit.h>
#include <linux/fault-inject.h>
#include "hfi.h"
#include "trace.h"
#include "debugfs.h"
#include "device.h"
#include "qp.h"
#include "sdma.h"
#include "fault.h"
static struct dentry *hfi1_dbg_root;
/* wrappers to enforce srcu in seq file */
ssize_t hfi1_seq_read(struct file *file, char __user *buf, size_t size,
loff_t *ppos)
{
struct dentry *d = file->f_path.dentry;
ssize_t r;
r = debugfs_file_get(d);
if (unlikely(r))
return r;
r = seq_read(file, buf, size, ppos);
debugfs_file_put(d);
return r;
}
loff_t hfi1_seq_lseek(struct file *file, loff_t offset, int whence)
{
struct dentry *d = file->f_path.dentry;
loff_t r;
r = debugfs_file_get(d);
if (unlikely(r))
return r;
r = seq_lseek(file, offset, whence);
debugfs_file_put(d);
return r;
}
#define private2dd(file) (file_inode(file)->i_private)
#define private2ppd(file) (file_inode(file)->i_private)
static void *_opcode_stats_seq_start(struct seq_file *s, loff_t *pos)
{
struct hfi1_opcode_stats_perctx *opstats;
if (*pos >= ARRAY_SIZE(opstats->stats))
return NULL;
return pos;
}
static void *_opcode_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct hfi1_opcode_stats_perctx *opstats;
++*pos;
if (*pos >= ARRAY_SIZE(opstats->stats))
return NULL;
return pos;
}
static void _opcode_stats_seq_stop(struct seq_file *s, void *v)
{
}
static int opcode_stats_show(struct seq_file *s, u8 i, u64 packets, u64 bytes)
{
if (!packets && !bytes)
return SEQ_SKIP;
seq_printf(s, "%02x %llu/%llu\n", i,
(unsigned long long)packets,
(unsigned long long)bytes);
return 0;
}
static int _opcode_stats_seq_show(struct seq_file *s, void *v)
{
loff_t *spos = v;
loff_t i = *spos, j;
u64 n_packets = 0, n_bytes = 0;
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
struct hfi1_ctxtdata *rcd;
for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
rcd = hfi1_rcd_get_by_index(dd, j);
if (rcd) {
n_packets += rcd->opstats->stats[i].n_packets;
n_bytes += rcd->opstats->stats[i].n_bytes;
}
hfi1_rcd_put(rcd);
}
return opcode_stats_show(s, i, n_packets, n_bytes);
}
DEBUGFS_SEQ_FILE_OPS(opcode_stats);
DEBUGFS_SEQ_FILE_OPEN(opcode_stats)
DEBUGFS_FILE_OPS(opcode_stats);
static void *_tx_opcode_stats_seq_start(struct seq_file *s, loff_t *pos)
{
return _opcode_stats_seq_start(s, pos);
}
static void *_tx_opcode_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
return _opcode_stats_seq_next(s, v, pos);
}
static void _tx_opcode_stats_seq_stop(struct seq_file *s, void *v)
{
}
static int _tx_opcode_stats_seq_show(struct seq_file *s, void *v)
{
loff_t *spos = v;
loff_t i = *spos;
int j;
u64 n_packets = 0, n_bytes = 0;
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
for_each_possible_cpu(j) {
struct hfi1_opcode_stats_perctx *s =
per_cpu_ptr(dd->tx_opstats, j);
n_packets += s->stats[i].n_packets;
n_bytes += s->stats[i].n_bytes;
}
return opcode_stats_show(s, i, n_packets, n_bytes);
}
DEBUGFS_SEQ_FILE_OPS(tx_opcode_stats);
DEBUGFS_SEQ_FILE_OPEN(tx_opcode_stats)
DEBUGFS_FILE_OPS(tx_opcode_stats);
static void *_ctx_stats_seq_start(struct seq_file *s, loff_t *pos)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
if (!*pos)
return SEQ_START_TOKEN;
if (*pos >= dd->first_dyn_alloc_ctxt)
return NULL;
return pos;
}
static void *_ctx_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
if (v == SEQ_START_TOKEN)
return pos;
++*pos;
if (*pos >= dd->first_dyn_alloc_ctxt)
return NULL;
return pos;
}
static void _ctx_stats_seq_stop(struct seq_file *s, void *v)
{
/* nothing allocated */
}
static int _ctx_stats_seq_show(struct seq_file *s, void *v)
{
loff_t *spos;
loff_t i, j;
u64 n_packets = 0;
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
struct hfi1_ctxtdata *rcd;
if (v == SEQ_START_TOKEN) {
seq_puts(s, "Ctx:npkts\n");
return 0;
}
spos = v;
i = *spos;
rcd = hfi1_rcd_get_by_index_safe(dd, i);
if (!rcd)
return SEQ_SKIP;
for (j = 0; j < ARRAY_SIZE(rcd->opstats->stats); j++)
n_packets += rcd->opstats->stats[j].n_packets;
hfi1_rcd_put(rcd);
if (!n_packets)
return SEQ_SKIP;
seq_printf(s, " %llu:%llu\n", i, n_packets);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(ctx_stats);
DEBUGFS_SEQ_FILE_OPEN(ctx_stats)
DEBUGFS_FILE_OPS(ctx_stats);
static void *_qp_stats_seq_start(struct seq_file *s, loff_t *pos)
__acquires(RCU)
{
struct rvt_qp_iter *iter;
loff_t n = *pos;
iter = rvt_qp_iter_init(s->private, 0, NULL);
/* stop calls rcu_read_unlock */
rcu_read_lock();
if (!iter)
return NULL;
do {
if (rvt_qp_iter_next(iter)) {
kfree(iter);
return NULL;
}
} while (n--);
return iter;
}
static void *_qp_stats_seq_next(struct seq_file *s, void *iter_ptr,
loff_t *pos)
__must_hold(RCU)
{
struct rvt_qp_iter *iter = iter_ptr;
(*pos)++;
if (rvt_qp_iter_next(iter)) {
kfree(iter);
return NULL;
}
return iter;
}
static void _qp_stats_seq_stop(struct seq_file *s, void *iter_ptr)
__releases(RCU)
{
rcu_read_unlock();
}
static int _qp_stats_seq_show(struct seq_file *s, void *iter_ptr)
{
struct rvt_qp_iter *iter = iter_ptr;
if (!iter)
return 0;
qp_iter_print(s, iter);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(qp_stats);
DEBUGFS_SEQ_FILE_OPEN(qp_stats)
DEBUGFS_FILE_OPS(qp_stats);
static void *_sdes_seq_start(struct seq_file *s, loff_t *pos)
{
struct hfi1_ibdev *ibd;
struct hfi1_devdata *dd;
ibd = (struct hfi1_ibdev *)s->private;
dd = dd_from_dev(ibd);
if (!dd->per_sdma || *pos >= dd->num_sdma)
return NULL;
return pos;
}
static void *_sdes_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
++*pos;
if (!dd->per_sdma || *pos >= dd->num_sdma)
return NULL;
return pos;
}
static void _sdes_seq_stop(struct seq_file *s, void *v)
{
}
static int _sdes_seq_show(struct seq_file *s, void *v)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
loff_t *spos = v;
loff_t i = *spos;
sdma_seqfile_dump_sde(s, &dd->per_sdma[i]);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(sdes);
DEBUGFS_SEQ_FILE_OPEN(sdes)
DEBUGFS_FILE_OPS(sdes);
static void *_rcds_seq_start(struct seq_file *s, loff_t *pos)
{
struct hfi1_ibdev *ibd;
struct hfi1_devdata *dd;
ibd = (struct hfi1_ibdev *)s->private;
dd = dd_from_dev(ibd);
if (!dd->rcd || *pos >= dd->n_krcv_queues)
return NULL;
return pos;
}
static void *_rcds_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
++*pos;
if (!dd->rcd || *pos >= dd->n_krcv_queues)
return NULL;
return pos;
}
static void _rcds_seq_stop(struct seq_file *s, void *v)
{
}
static int _rcds_seq_show(struct seq_file *s, void *v)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
struct hfi1_ctxtdata *rcd;
loff_t *spos = v;
loff_t i = *spos;
rcd = hfi1_rcd_get_by_index_safe(dd, i);
if (rcd)
seqfile_dump_rcd(s, rcd);
hfi1_rcd_put(rcd);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(rcds);
DEBUGFS_SEQ_FILE_OPEN(rcds)
DEBUGFS_FILE_OPS(rcds);
static void *_pios_seq_start(struct seq_file *s, loff_t *pos)
{
struct hfi1_ibdev *ibd;
struct hfi1_devdata *dd;
ibd = (struct hfi1_ibdev *)s->private;
dd = dd_from_dev(ibd);
if (!dd->send_contexts || *pos >= dd->num_send_contexts)
return NULL;
return pos;
}
static void *_pios_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
++*pos;
if (!dd->send_contexts || *pos >= dd->num_send_contexts)
return NULL;
return pos;
}
static void _pios_seq_stop(struct seq_file *s, void *v)
{
}
static int _pios_seq_show(struct seq_file *s, void *v)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
struct send_context_info *sci;
loff_t *spos = v;
loff_t i = *spos;
unsigned long flags;
spin_lock_irqsave(&dd->sc_lock, flags);
sci = &dd->send_contexts[i];
if (sci && sci->type != SC_USER && sci->allocated && sci->sc)
seqfile_dump_sci(s, i, sci);
spin_unlock_irqrestore(&dd->sc_lock, flags);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(pios);
DEBUGFS_SEQ_FILE_OPEN(pios)
DEBUGFS_FILE_OPS(pios);
/* read the per-device counters */
static ssize_t dev_counters_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
u64 *counters;
size_t avail;
struct hfi1_devdata *dd;
ssize_t rval;
dd = private2dd(file);
avail = hfi1_read_cntrs(dd, NULL, &counters);
rval = simple_read_from_buffer(buf, count, ppos, counters, avail);
return rval;
}
/* read the per-device counters */
static ssize_t dev_names_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
char *names;
size_t avail;
struct hfi1_devdata *dd;
ssize_t rval;
dd = private2dd(file);
avail = hfi1_read_cntrs(dd, &names, NULL);
rval = simple_read_from_buffer(buf, count, ppos, names, avail);
return rval;
}
struct counter_info {
char *name;
const struct file_operations ops;
};
/*
* Could use file_inode(file)->i_ino to figure out which file,
* instead of separate routine for each, but for now, this works...
*/
/* read the per-port names (same for each port) */
static ssize_t portnames_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
char *names;
size_t avail;
struct hfi1_devdata *dd;
ssize_t rval;
dd = private2dd(file);
avail = hfi1_read_portcntrs(dd->pport, &names, NULL);
rval = simple_read_from_buffer(buf, count, ppos, names, avail);
return rval;
}
/* read the per-port counters */
static ssize_t portcntrs_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
u64 *counters;
size_t avail;
struct hfi1_pportdata *ppd;
ssize_t rval;
ppd = private2ppd(file);
avail = hfi1_read_portcntrs(ppd, NULL, &counters);
rval = simple_read_from_buffer(buf, count, ppos, counters, avail);
return rval;
}
static void check_dyn_flag(u64 scratch0, char *p, int size, int *used,
int this_hfi, int hfi, u32 flag, const char *what)
{
u32 mask;
mask = flag << (hfi ? CR_DYN_SHIFT : 0);
if (scratch0 & mask) {
*used += scnprintf(p + *used, size - *used,
" 0x%08x - HFI%d %s in use, %s device\n",
mask, hfi, what,
this_hfi == hfi ? "this" : "other");
}
}
static ssize_t asic_flags_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd;
struct hfi1_devdata *dd;
u64 scratch0;
char *tmp;
int ret = 0;
int size;
int used;
int i;
ppd = private2ppd(file);
dd = ppd->dd;
size = PAGE_SIZE;
used = 0;
tmp = kmalloc(size, GFP_KERNEL);
if (!tmp)
return -ENOMEM;
scratch0 = read_csr(dd, ASIC_CFG_SCRATCH);
used += scnprintf(tmp + used, size - used,
"Resource flags: 0x%016llx\n", scratch0);
/* check permanent flag */
if (scratch0 & CR_THERM_INIT) {
used += scnprintf(tmp + used, size - used,
" 0x%08x - thermal monitoring initialized\n",
(u32)CR_THERM_INIT);
}
/* check each dynamic flag on each HFI */
for (i = 0; i < 2; i++) {
check_dyn_flag(scratch0, tmp, size, &used, dd->hfi1_id, i,
CR_SBUS, "SBus");
check_dyn_flag(scratch0, tmp, size, &used, dd->hfi1_id, i,
CR_EPROM, "EPROM");
check_dyn_flag(scratch0, tmp, size, &used, dd->hfi1_id, i,
CR_I2C1, "i2c chain 1");
check_dyn_flag(scratch0, tmp, size, &used, dd->hfi1_id, i,
CR_I2C2, "i2c chain 2");
}
used += scnprintf(tmp + used, size - used, "Write bits to clear\n");
ret = simple_read_from_buffer(buf, count, ppos, tmp, used);
kfree(tmp);
return ret;
}
static ssize_t asic_flags_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd;
struct hfi1_devdata *dd;
char *buff;
int ret;
unsigned long long value;
u64 scratch0;
u64 clear;
ppd = private2ppd(file);
dd = ppd->dd;
/* zero terminate and read the expected integer */
buff = memdup_user_nul(buf, count);
if (IS_ERR(buff))
return PTR_ERR(buff);
ret = kstrtoull(buff, 0, &value);
if (ret)
goto do_free;
clear = value;
/* obtain exclusive access */
mutex_lock(&dd->asic_data->asic_resource_mutex);
acquire_hw_mutex(dd);
scratch0 = read_csr(dd, ASIC_CFG_SCRATCH);
scratch0 &= ~clear;
write_csr(dd, ASIC_CFG_SCRATCH, scratch0);
/* force write to be visible to other HFI on another OS */
(void)read_csr(dd, ASIC_CFG_SCRATCH);
release_hw_mutex(dd);
mutex_unlock(&dd->asic_data->asic_resource_mutex);
/* return the number of bytes written */
ret = count;
do_free:
kfree(buff);
return ret;
}
/* read the dc8051 memory */
static ssize_t dc8051_memory_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd = private2ppd(file);
ssize_t rval;
void *tmp;
loff_t start, end;
/* the checks below expect the position to be positive */
if (*ppos < 0)
return -EINVAL;
tmp = kzalloc(DC8051_DATA_MEM_SIZE, GFP_KERNEL);
if (!tmp)
return -ENOMEM;
/*
* Fill in the requested portion of the temporary buffer from the
* 8051 memory. The 8051 memory read is done in terms of 8 bytes.
* Adjust start and end to fit. Skip reading anything if out of
* range.
*/
start = *ppos & ~0x7; /* round down */
if (start < DC8051_DATA_MEM_SIZE) {
end = (*ppos + count + 7) & ~0x7; /* round up */
if (end > DC8051_DATA_MEM_SIZE)
end = DC8051_DATA_MEM_SIZE;
rval = read_8051_data(ppd->dd, start, end - start,
(u64 *)(tmp + start));
if (rval)
goto done;
}
rval = simple_read_from_buffer(buf, count, ppos, tmp,
DC8051_DATA_MEM_SIZE);
done:
kfree(tmp);
return rval;
}
static ssize_t debugfs_lcb_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd = private2ppd(file);
struct hfi1_devdata *dd = ppd->dd;
unsigned long total, csr_off;
u64 data;
if (*ppos < 0)
return -EINVAL;
/* only read 8 byte quantities */
if ((count % 8) != 0)
return -EINVAL;
/* offset must be 8-byte aligned */
if ((*ppos % 8) != 0)
return -EINVAL;
/* do nothing if out of range or zero count */
if (*ppos >= (LCB_END - LCB_START) || !count)
return 0;
/* reduce count if needed */
if (*ppos + count > LCB_END - LCB_START)
count = (LCB_END - LCB_START) - *ppos;
csr_off = LCB_START + *ppos;
for (total = 0; total < count; total += 8, csr_off += 8) {
if (read_lcb_csr(dd, csr_off, (u64 *)&data))
break; /* failed */
if (put_user(data, (unsigned long __user *)(buf + total)))
break;
}
*ppos += total;
return total;
}
static ssize_t debugfs_lcb_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd = private2ppd(file);
struct hfi1_devdata *dd = ppd->dd;
unsigned long total, csr_off, data;
if (*ppos < 0)
return -EINVAL;
/* only write 8 byte quantities */
if ((count % 8) != 0)
return -EINVAL;
/* offset must be 8-byte aligned */
if ((*ppos % 8) != 0)
return -EINVAL;
/* do nothing if out of range or zero count */
if (*ppos >= (LCB_END - LCB_START) || !count)
return 0;
/* reduce count if needed */
if (*ppos + count > LCB_END - LCB_START)
count = (LCB_END - LCB_START) - *ppos;
csr_off = LCB_START + *ppos;
for (total = 0; total < count; total += 8, csr_off += 8) {
if (get_user(data, (unsigned long __user *)(buf + total)))
break;
if (write_lcb_csr(dd, csr_off, data))
break; /* failed */
}
*ppos += total;
return total;
}
/*
* read the per-port QSFP data for ppd
*/
static ssize_t qsfp_debugfs_dump(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct hfi1_pportdata *ppd;
char *tmp;
int ret;
ppd = private2ppd(file);
tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!tmp)
return -ENOMEM;
ret = qsfp_dump(ppd, tmp, PAGE_SIZE);
if (ret > 0)
ret = simple_read_from_buffer(buf, count, ppos, tmp, ret);
kfree(tmp);
return ret;
}
/* Do an i2c write operation on the chain for the given HFI. */
static ssize_t __i2c_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos, u32 target)
{
struct hfi1_pportdata *ppd;
char *buff;
int ret;
int i2c_addr;
int offset;
int total_written;
ppd = private2ppd(file);
/* byte offset format: [offsetSize][i2cAddr][offsetHigh][offsetLow] */
i2c_addr = (*ppos >> 16) & 0xffff;
offset = *ppos & 0xffff;
/* explicitly reject invalid address 0 to catch cp and cat */
if (i2c_addr == 0)
return -EINVAL;
buff = memdup_user(buf, count);
if (IS_ERR(buff))
return PTR_ERR(buff);
total_written = i2c_write(ppd, target, i2c_addr, offset, buff, count);
if (total_written < 0) {
ret = total_written;
goto _free;
}
*ppos += total_written;
ret = total_written;
_free:
kfree(buff);
return ret;
}
/* Do an i2c write operation on chain for HFI 0. */
static ssize_t i2c1_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return __i2c_debugfs_write(file, buf, count, ppos, 0);
}
/* Do an i2c write operation on chain for HFI 1. */
static ssize_t i2c2_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return __i2c_debugfs_write(file, buf, count, ppos, 1);
}
/* Do an i2c read operation on the chain for the given HFI. */
static ssize_t __i2c_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos, u32 target)
{
struct hfi1_pportdata *ppd;
char *buff;
int ret;
int i2c_addr;
int offset;
int total_read;
ppd = private2ppd(file);
/* byte offset format: [offsetSize][i2cAddr][offsetHigh][offsetLow] */
i2c_addr = (*ppos >> 16) & 0xffff;
offset = *ppos & 0xffff;
/* explicitly reject invalid address 0 to catch cp and cat */
if (i2c_addr == 0)
return -EINVAL;
buff = kmalloc(count, GFP_KERNEL);
if (!buff)
return -ENOMEM;
total_read = i2c_read(ppd, target, i2c_addr, offset, buff, count);
if (total_read < 0) {
ret = total_read;
goto _free;
}
*ppos += total_read;
ret = copy_to_user(buf, buff, total_read);
if (ret > 0) {
ret = -EFAULT;
goto _free;
}
ret = total_read;
_free:
kfree(buff);
return ret;
}
/* Do an i2c read operation on chain for HFI 0. */
static ssize_t i2c1_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
return __i2c_debugfs_read(file, buf, count, ppos, 0);
}
/* Do an i2c read operation on chain for HFI 1. */
static ssize_t i2c2_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
return __i2c_debugfs_read(file, buf, count, ppos, 1);
}
/* Do a QSFP write operation on the i2c chain for the given HFI. */
static ssize_t __qsfp_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos, u32 target)
{
struct hfi1_pportdata *ppd;
char *buff;
int ret;
int total_written;
if (*ppos + count > QSFP_PAGESIZE * 4) /* base page + page00-page03 */
return -EINVAL;
ppd = private2ppd(file);
buff = memdup_user(buf, count);
if (IS_ERR(buff))
return PTR_ERR(buff);
total_written = qsfp_write(ppd, target, *ppos, buff, count);
if (total_written < 0) {
ret = total_written;
goto _free;
}
*ppos += total_written;
ret = total_written;
_free:
kfree(buff);
return ret;
}
/* Do a QSFP write operation on i2c chain for HFI 0. */
static ssize_t qsfp1_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return __qsfp_debugfs_write(file, buf, count, ppos, 0);
}
/* Do a QSFP write operation on i2c chain for HFI 1. */
static ssize_t qsfp2_debugfs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return __qsfp_debugfs_write(file, buf, count, ppos, 1);
}
/* Do a QSFP read operation on the i2c chain for the given HFI. */
static ssize_t __qsfp_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos, u32 target)
{
struct hfi1_pportdata *ppd;
char *buff;
int ret;
int total_read;
if (*ppos + count > QSFP_PAGESIZE * 4) { /* base page + page00-page03 */
ret = -EINVAL;
goto _return;
}
ppd = private2ppd(file);
buff = kmalloc(count, GFP_KERNEL);
if (!buff) {
ret = -ENOMEM;
goto _return;
}
total_read = qsfp_read(ppd, target, *ppos, buff, count);
if (total_read < 0) {
ret = total_read;
goto _free;
}
*ppos += total_read;
ret = copy_to_user(buf, buff, total_read);
if (ret > 0) {
ret = -EFAULT;
goto _free;
}
ret = total_read;
_free:
kfree(buff);
_return:
return ret;
}
/* Do a QSFP read operation on i2c chain for HFI 0. */
static ssize_t qsfp1_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
return __qsfp_debugfs_read(file, buf, count, ppos, 0);
}
/* Do a QSFP read operation on i2c chain for HFI 1. */
static ssize_t qsfp2_debugfs_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
return __qsfp_debugfs_read(file, buf, count, ppos, 1);
}
static int __i2c_debugfs_open(struct inode *in, struct file *fp, u32 target)
{
struct hfi1_pportdata *ppd;
int ret;
if (!try_module_get(THIS_MODULE))
return -ENODEV;
ppd = private2ppd(fp);
ret = acquire_chip_resource(ppd->dd, i2c_target(target), 0);
if (ret) /* failed - release the module */
module_put(THIS_MODULE);
return ret;
}
static int i2c1_debugfs_open(struct inode *in, struct file *fp)
{
return __i2c_debugfs_open(in, fp, 0);
}
static int i2c2_debugfs_open(struct inode *in, struct file *fp)
{
return __i2c_debugfs_open(in, fp, 1);
}
static int __i2c_debugfs_release(struct inode *in, struct file *fp, u32 target)
{
struct hfi1_pportdata *ppd;
ppd = private2ppd(fp);
release_chip_resource(ppd->dd, i2c_target(target));
module_put(THIS_MODULE);
return 0;
}
static int i2c1_debugfs_release(struct inode *in, struct file *fp)
{
return __i2c_debugfs_release(in, fp, 0);
}
static int i2c2_debugfs_release(struct inode *in, struct file *fp)
{
return __i2c_debugfs_release(in, fp, 1);
}
static int __qsfp_debugfs_open(struct inode *in, struct file *fp, u32 target)
{
struct hfi1_pportdata *ppd;
int ret;
if (!try_module_get(THIS_MODULE))
return -ENODEV;
ppd = private2ppd(fp);
ret = acquire_chip_resource(ppd->dd, i2c_target(target), 0);
if (ret) /* failed - release the module */
module_put(THIS_MODULE);
return ret;
}
static int qsfp1_debugfs_open(struct inode *in, struct file *fp)
{
return __qsfp_debugfs_open(in, fp, 0);
}
static int qsfp2_debugfs_open(struct inode *in, struct file *fp)
{
return __qsfp_debugfs_open(in, fp, 1);
}
static int __qsfp_debugfs_release(struct inode *in, struct file *fp, u32 target)
{
struct hfi1_pportdata *ppd;
ppd = private2ppd(fp);
release_chip_resource(ppd->dd, i2c_target(target));
module_put(THIS_MODULE);
return 0;
}
static int qsfp1_debugfs_release(struct inode *in, struct file *fp)
{
return __qsfp_debugfs_release(in, fp, 0);
}
static int qsfp2_debugfs_release(struct inode *in, struct file *fp)
{
return __qsfp_debugfs_release(in, fp, 1);
}
#define DEBUGFS_OPS(nm, readroutine, writeroutine) \
{ \
.name = nm, \
.ops = { \
.read = readroutine, \
.write = writeroutine, \
.llseek = generic_file_llseek, \
}, \
}
#define DEBUGFS_XOPS(nm, readf, writef, openf, releasef) \
{ \
.name = nm, \
.ops = { \
.read = readf, \
.write = writef, \
.llseek = generic_file_llseek, \
.open = openf, \
.release = releasef \
}, \
}
static const struct counter_info cntr_ops[] = {
DEBUGFS_OPS("counter_names", dev_names_read, NULL),
DEBUGFS_OPS("counters", dev_counters_read, NULL),
DEBUGFS_OPS("portcounter_names", portnames_read, NULL),
};
static const struct counter_info port_cntr_ops[] = {
DEBUGFS_OPS("port%dcounters", portcntrs_debugfs_read, NULL),
DEBUGFS_XOPS("i2c1", i2c1_debugfs_read, i2c1_debugfs_write,
i2c1_debugfs_open, i2c1_debugfs_release),
DEBUGFS_XOPS("i2c2", i2c2_debugfs_read, i2c2_debugfs_write,
i2c2_debugfs_open, i2c2_debugfs_release),
DEBUGFS_OPS("qsfp_dump%d", qsfp_debugfs_dump, NULL),
DEBUGFS_XOPS("qsfp1", qsfp1_debugfs_read, qsfp1_debugfs_write,
qsfp1_debugfs_open, qsfp1_debugfs_release),
DEBUGFS_XOPS("qsfp2", qsfp2_debugfs_read, qsfp2_debugfs_write,
qsfp2_debugfs_open, qsfp2_debugfs_release),
DEBUGFS_OPS("asic_flags", asic_flags_read, asic_flags_write),
DEBUGFS_OPS("dc8051_memory", dc8051_memory_read, NULL),
DEBUGFS_OPS("lcb", debugfs_lcb_read, debugfs_lcb_write),
};
static void *_sdma_cpu_list_seq_start(struct seq_file *s, loff_t *pos)
{
if (*pos >= num_online_cpus())
return NULL;
return pos;
}
static void *_sdma_cpu_list_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
++*pos;
if (*pos >= num_online_cpus())
return NULL;
return pos;
}
static void _sdma_cpu_list_seq_stop(struct seq_file *s, void *v)
{
/* nothing allocated */
}
static int _sdma_cpu_list_seq_show(struct seq_file *s, void *v)
{
struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
struct hfi1_devdata *dd = dd_from_dev(ibd);
loff_t *spos = v;
loff_t i = *spos;
sdma_seqfile_dump_cpu_list(s, dd, (unsigned long)i);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(sdma_cpu_list);
DEBUGFS_SEQ_FILE_OPEN(sdma_cpu_list)
DEBUGFS_FILE_OPS(sdma_cpu_list);
void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd)
{
char name[sizeof("port0counters") + 1];
char link[10];
struct hfi1_devdata *dd = dd_from_dev(ibd);
struct hfi1_pportdata *ppd;
struct dentry *root;
int unit = dd->unit;
int i, j;
if (!hfi1_dbg_root)
return;
snprintf(name, sizeof(name), "%s_%d", class_name(), unit);
snprintf(link, sizeof(link), "%d", unit);
root = debugfs_create_dir(name, hfi1_dbg_root);
ibd->hfi1_ibdev_dbg = root;
ibd->hfi1_ibdev_link =
debugfs_create_symlink(link, hfi1_dbg_root, name);
debugfs_create_file("opcode_stats", 0444, root, ibd,
&_opcode_stats_file_ops);
debugfs_create_file("tx_opcode_stats", 0444, root, ibd,
&_tx_opcode_stats_file_ops);
debugfs_create_file("ctx_stats", 0444, root, ibd, &_ctx_stats_file_ops);
debugfs_create_file("qp_stats", 0444, root, ibd, &_qp_stats_file_ops);
debugfs_create_file("sdes", 0444, root, ibd, &_sdes_file_ops);
debugfs_create_file("rcds", 0444, root, ibd, &_rcds_file_ops);
debugfs_create_file("pios", 0444, root, ibd, &_pios_file_ops);
debugfs_create_file("sdma_cpu_list", 0444, root, ibd,
&_sdma_cpu_list_file_ops);
/* dev counter files */
for (i = 0; i < ARRAY_SIZE(cntr_ops); i++)
debugfs_create_file(cntr_ops[i].name, 0444, root, dd,
&cntr_ops[i].ops);
/* per port files */
for (ppd = dd->pport, j = 0; j < dd->num_pports; j++, ppd++)
for (i = 0; i < ARRAY_SIZE(port_cntr_ops); i++) {
snprintf(name,
sizeof(name),
port_cntr_ops[i].name,
j + 1);
debugfs_create_file(name,
!port_cntr_ops[i].ops.write ?
S_IRUGO :
S_IRUGO | S_IWUSR,
root, ppd, &port_cntr_ops[i].ops);
}
hfi1_fault_init_debugfs(ibd);
}
void hfi1_dbg_ibdev_exit(struct hfi1_ibdev *ibd)
{
if (!hfi1_dbg_root)
goto out;
hfi1_fault_exit_debugfs(ibd);
debugfs_remove(ibd->hfi1_ibdev_link);
debugfs_remove_recursive(ibd->hfi1_ibdev_dbg);
out:
ibd->hfi1_ibdev_dbg = NULL;
}
/*
* driver stats field names, one line per stat, single string. Used by
* programs like hfistats to print the stats in a way which works for
* different versions of drivers, without changing program source.
* if hfi1_ib_stats changes, this needs to change. Names need to be
* 12 chars or less (w/o newline), for proper display by hfistats utility.
*/
static const char * const hfi1_statnames[] = {
/* must be element 0*/
"KernIntr",
"ErrorIntr",
"Tx_Errs",
"Rcv_Errs",
"H/W_Errs",
"NoPIOBufs",
"CtxtsOpen",
"RcvLen_Errs",
"EgrBufFull",
"EgrHdrFull"
};
static void *_driver_stats_names_seq_start(struct seq_file *s, loff_t *pos)
{
if (*pos >= ARRAY_SIZE(hfi1_statnames))
return NULL;
return pos;
}
static void *_driver_stats_names_seq_next(
struct seq_file *s,
void *v,
loff_t *pos)
{
++*pos;
if (*pos >= ARRAY_SIZE(hfi1_statnames))
return NULL;
return pos;
}
static void _driver_stats_names_seq_stop(struct seq_file *s, void *v)
{
}
static int _driver_stats_names_seq_show(struct seq_file *s, void *v)
{
loff_t *spos = v;
seq_printf(s, "%s\n", hfi1_statnames[*spos]);
return 0;
}
DEBUGFS_SEQ_FILE_OPS(driver_stats_names);
DEBUGFS_SEQ_FILE_OPEN(driver_stats_names)
DEBUGFS_FILE_OPS(driver_stats_names);
static void *_driver_stats_seq_start(struct seq_file *s, loff_t *pos)
{
if (*pos >= ARRAY_SIZE(hfi1_statnames))
return NULL;
return pos;
}
static void *_driver_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
++*pos;
if (*pos >= ARRAY_SIZE(hfi1_statnames))
return NULL;
return pos;
}
static void _driver_stats_seq_stop(struct seq_file *s, void *v)
{
}
static u64 hfi1_sps_ints(void)
{
unsigned long flags;
struct hfi1_devdata *dd;
u64 sps_ints = 0;
spin_lock_irqsave(&hfi1_devs_lock, flags);
list_for_each_entry(dd, &hfi1_dev_list, list) {
sps_ints += get_all_cpu_total(dd->int_counter);
}
spin_unlock_irqrestore(&hfi1_devs_lock, flags);
return sps_ints;
}
static int _driver_stats_seq_show(struct seq_file *s, void *v)
{
loff_t *spos = v;
char *buffer;
u64 *stats = (u64 *)&hfi1_stats;
size_t sz = seq_get_buf(s, &buffer);
if (sz < sizeof(u64))
return SEQ_SKIP;
/* special case for interrupts */
if (*spos == 0)
*(u64 *)buffer = hfi1_sps_ints();
else
*(u64 *)buffer = stats[*spos];
seq_commit(s, sizeof(u64));
return 0;
}
DEBUGFS_SEQ_FILE_OPS(driver_stats);
DEBUGFS_SEQ_FILE_OPEN(driver_stats)
DEBUGFS_FILE_OPS(driver_stats);
void hfi1_dbg_init(void)
{
hfi1_dbg_root = debugfs_create_dir(DRIVER_NAME, NULL);
debugfs_create_file("driver_stats_names", 0444, hfi1_dbg_root, NULL,
&_driver_stats_names_file_ops);
debugfs_create_file("driver_stats", 0444, hfi1_dbg_root, NULL,
&_driver_stats_file_ops);
}
void hfi1_dbg_exit(void)
{
debugfs_remove_recursive(hfi1_dbg_root);
hfi1_dbg_root = NULL;
}
|
329852.c | /*
* (C) 2001 Clemson University and The University of Chicago
*
* See COPYING in top-level directory.
*/
#include <stdio.h>
int main(
int argc,
char **argv)
{
int message_size = 0;
float total_lat = 0.0;
float ind_lat = 0.0;
float ind_ave, total_ave;
int i;
int ret = 0;
char char_buffer[256];
while (1)
{
ind_ave = 0.0;
total_ave = 0.0;
for (i = 0; i < 5; i++)
{
if (fgets(char_buffer, 254, stdin) == NULL)
{
return (0);
}
ret = sscanf(char_buffer, "%d\t%f\t%f",
&message_size, &total_lat, &ind_lat);
ind_ave += ind_lat;
total_ave += total_lat;
if (ret < 3)
{
fprintf(stderr, "parse error.\n");
return (-1);
}
}
ind_ave /= 5.0;
total_ave /= 5.0;
printf("%d %f %f (size,total,ind)\n", message_size, total_ave, ind_ave);
}
return (0);
}
/*
* Local variables:
* c-indent-level: 4
* c-basic-offset: 4
* End:
*
* vim: ts=8 sts=4 sw=4 expandtab
*/
|
628387.c | #include "xvmaininc.h"
#include <stdio.h>
#if VMS_OS
#else
#include <sys/types.h>
#include <sys/wait.h>
#endif
#include "ms_defines.h"
#include "cltsub.h"
main (int argc, char **argv)
{
int sd;
msUserRequestStruct req;
msCkStruct ckdata;
msSpkStruct spkdata;
const char *cm = "tstMsClient";
printf ("***** ************************* ******\n");
printf ("***** DOING REMOTE GLL_GETSPICE ******\n");
printf ("***** ************************* ******\n");
memset ((void*) &req, '\0', sizeof(req));
req.sc_id = -77;
req.system = REF_B1950;
req.scet[0] = 1990;
req.scet[1] = 44;
req.scet[2] = 5;
req.scet[3] = 58;
req.scet[4] = 16;
req.scet[5] = 962;
strcpy (req.instrument_name, "SSI");
strcpy (req.target_name, "VENUS");
strcpy (req.ck_source, "NEAR");
strcpy (req.provInfo.seg_id, "NONENONE*NONE*NONENONE000000000000*NONE*");
memset ((void*) &ckdata, '\0', sizeof(ckdata));
memset ((void*) &spkdata, '\0', sizeof(spkdata));
if (msclt_gllgetspice(&req, &ckdata, &spkdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR getting GLL SPICE");
exit (0);
}
printf ("***** ************************* ******\n");
printf ("***** DOING REMOTE GLL_PUTSPICE ******\n");
printf ("***** ************************* ******\n");
if (msclt_gllputspice(&ckdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR writing to remote kernel");
exit (0);
}
else fprintf (stderr, "GLL Kernel write SUCCESSFULL !!!\n");
/*
printf ("***** ************************** ******\n");
printf ("***** DOING REMOTE VGR1_GETSPICE ******\n");
printf ("***** ************************** ******\n");
memset ((void*) &req, '\0', sizeof(req));
req.sc_id = VGR_1_SC_ID;
req.system = REF_B1950;
req.scet[0] = 1979;
req.scet[1] = 63;
req.scet[2] = 19;
req.scet[3] = 23;
req.scet[4] = 0;
req.scet[5] = 0;
strcpy (req.provInfo.seg_id, "NONENONE*NONE*NONENONE000000000000*NONE*");
strcpy (req.instrument_name, "ISSN");
strcpy (req.target_name, "IO");
strcpy (req.ck_source, "NEAR");
memset ((void*) &ckdata, '\0', sizeof(ckdata));
memset ((void*) &spkdata, '\0', sizeof(spkdata));
if (msclt_vgr1getspice(&req, &ckdata, &spkdata)) {
fprintf (stderr, "%s:%s\n", cm, "ERROR getting VGR1 SPICE");
}
printf ("***** ************************** ******\n");
printf ("***** DOING REMOTE VGR1_PUTSPICE ******\n");
printf ("***** ************************** ******\n");
if (msclt_vgr1putspice(&ckdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR writing to remote kernel");
exit (0);
}
else fprintf (stderr, "VGR1 Kernel write SUCCESSFULL !!!\n");
printf ("***** ************************** ******\n");
printf ("***** DOING REMOTE VGR2_GETSPICE ******\n");
printf ("***** ************************** ******\n");
memset ((void*) &req, '\0', sizeof(req));
req.sc_id = VGR_2_SC_ID;
req.system = REF_B1950;
req.scet[0] = 1979;
req.scet[1] = 160;
req.scet[2] = 0;
req.scet[3] = 0;
req.scet[4] = 0;
req.scet[5] = 0;
strcpy (req.provInfo.seg_id, "NONENONE*NONE*NONENONE000000000000*NONE*");
strcpy (req.instrument_name, "ISSN");
strcpy (req.target_name, "JUPITER");
strcpy (req.ck_source, "NEAR");
memset ((void*) &ckdata, '\0', sizeof(ckdata));
memset ((void*) &spkdata, '\0', sizeof(spkdata));
if (msclt_vgr2getspice(&req, &ckdata, &spkdata)) {
fprintf (stderr, "%s:%s\n", cm, "ERROR getting VGR2 SPICE");
}
printf ("***** ************************** ******\n");
printf ("***** DOING REMOTE VGR2_PUTSPICE ******\n");
printf ("***** ************************** ******\n");
if (msclt_vgr2putspice(&ckdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR writing to remote kernel");
exit (0);
}
else fprintf (stderr, "VGR2 Kernel write SUCCESSFULL !!!\n");
*/
printf ("***** ************************* ******\n");
printf ("***** DOING REMOTE CAS_GETSPICE ******\n");
printf ("***** ************************* ******\n");
memset ((void*) &req, '\0', sizeof(req));
req.sc_id = -82;
req.system = REF_B1950;
req.scet[0] = 2000;
req.scet[1] = 350;
req.scet[2] = 0;
req.scet[3] = 0;
req.scet[4] = 0;
req.scet[5] = 0;
strcpy (req.instrument_name, "ISSN");
strcpy (req.target_name, "JUPITER");
strcpy (req.ck_source, "NEAR");
strcpy (req.provInfo.seg_id, "NONENONE*NONE*NONENONE000000000000*NONE*");
memset ((void*) &ckdata, '\0', sizeof(ckdata));
memset ((void*) &spkdata, '\0', sizeof(spkdata));
if (msclt_casgetspice(&req, &ckdata, &spkdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR getting CAS SPICE");
exit (0);
}
printf ("***** ************************* ******\n");
printf ("***** DOING REMOTE CAS_PUTSPICE ******\n");
printf ("***** ************************* ******\n");
strcpy (ckdata.ck_id, "M902");
ckdata.instrument = CASISSNA_NAIF_ID;
if (msclt_casputspice(&ckdata)) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR writing to remote kernel");
exit (0);
}
else fprintf (stderr, "CAS Kernel write SUCCESSFULL !!!\n");
/****************************
printf ("\n***** REQUEST ******\n");
msclt_printuserrequeststruct(req);
printf ("\n***** CKDATA ******\n");
msclt_printckstruct(ckdata);
printf ("\n***** SPKDATA ******\n");
msclt_printspkstruct(spkdata);
printf ("***** **************** ******\n");
printf ("***** DOING GLL_GET_CK ******\n");
printf ("***** **************** ******\n");
if (msclt_gllgetck("mips_nav2.ck", "/home/sle")) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR writing to remote kernel");
exit (0);
}
if (msclt_gllgetspk ("gll_long_2.bsp", "/home/sle")) {
fprintf (stderr, "%s:%s\n", cm,
"ERROR reading SPK from server");
exit(0);
}
***************************/
}
|
386010.c | /*
Copyright (C) 2014, The University of Texas at Austin
This file is part of libflame and is available under the 3-Clause
BSD license, which can be found in the LICENSE file at the top-level
directory, or at http://opensource.org/licenses/BSD-3-Clause
*/
#include "FLAME.h"
FLA_Error FLA_Tridiag_UT_scale_diagonals( FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A )
{
FLA_Error r_val = FLA_SUCCESS;
if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
FLA_Tridiag_UT_scale_diagonals_check( uplo, alpha, A );
if ( uplo == FLA_LOWER_TRIANGULAR )
r_val = FLA_Bidiag_UT_l_scale_diagonals( alpha, A );
else
r_val = FLA_Bidiag_UT_u_scale_diagonals( alpha, A );
return r_val;
}
|
340198.c | /*
* File: ex_2.c
* Author: Vinicius
*/
#include <stdio.h>
#include <stdlib.h>
char* inverte_letra (char* str);
int main() {
char str[20];
char *p;
printf("Digite a palavra: ");
scanf("%s",str);
getchar();
p=inverte_letra (str);
printf("Antiga: %s\nNova: %s ",str,p);
return (EXIT_SUCCESS);
}
char* inverte_letra (char* str){
int i;
char *p;
for(i=0;str[i];i++){
if(*(str+i) >= 'a' && str[i] <= 'z'){
*(p+i) = str[i] -32 ;}
else if(*(str+i) >= 'A' && str[i] <= 'Z'){
*(p+i) = str[i] +32 ;}
else *(p+i) = str[i];
}
*(p+i) = '\0';
return p;
} |
31696.c | // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
//
// This file is provided under a dual BSD/GPLv2 license. When using or
// redistributing this file, you may do so under either license.
//
// Copyright(c) 2018 Intel Corporation. All rights reserved.
//
// Author: Liam Girdwood <[email protected]>
//
// Generic firmware loader.
//
#include <linux/firmware.h>
#include <sound/sof.h>
#include "ops.h"
static int get_ext_windows(struct snd_sof_dev *sdev,
struct sof_ipc_ext_data_hdr *ext_hdr)
{
struct sof_ipc_window *w =
container_of(ext_hdr, struct sof_ipc_window, ext_hdr);
if (w->num_windows == 0 || w->num_windows > SOF_IPC_MAX_ELEMS)
return -EINVAL;
/* keep a local copy of the data */
sdev->info_window = kmemdup(w, struct_size(w, window, w->num_windows),
GFP_KERNEL);
if (!sdev->info_window)
return -ENOMEM;
return 0;
}
/* parse the extended FW boot data structures from FW boot message */
int snd_sof_fw_parse_ext_data(struct snd_sof_dev *sdev, u32 bar, u32 offset)
{
struct sof_ipc_ext_data_hdr *ext_hdr;
void *ext_data;
int ret = 0;
ext_data = kzalloc(PAGE_SIZE, GFP_KERNEL);
if (!ext_data)
return -ENOMEM;
/* get first header */
snd_sof_dsp_block_read(sdev, bar, offset, ext_data,
sizeof(*ext_hdr));
ext_hdr = ext_data;
while (ext_hdr->hdr.cmd == SOF_IPC_FW_READY) {
/* read in ext structure */
offset += sizeof(*ext_hdr);
snd_sof_dsp_block_read(sdev, bar, offset,
(void *)((u8 *)ext_data + sizeof(*ext_hdr)),
ext_hdr->hdr.size - sizeof(*ext_hdr));
dev_dbg(sdev->dev, "found ext header type %d size 0x%x\n",
ext_hdr->type, ext_hdr->hdr.size);
/* process structure data */
switch (ext_hdr->type) {
case SOF_IPC_EXT_DMA_BUFFER:
break;
case SOF_IPC_EXT_WINDOW:
ret = get_ext_windows(sdev, ext_hdr);
break;
default:
dev_warn(sdev->dev, "warning: unknown ext header type %d size 0x%x\n",
ext_hdr->type, ext_hdr->hdr.size);
break;
}
if (ret < 0) {
dev_err(sdev->dev, "error: failed to parse ext data type %d\n",
ext_hdr->type);
break;
}
/* move to next header */
offset += ext_hdr->hdr.size;
snd_sof_dsp_block_read(sdev, bar, offset, ext_data,
sizeof(*ext_hdr));
ext_hdr = ext_data;
}
kfree(ext_data);
return ret;
}
EXPORT_SYMBOL(snd_sof_fw_parse_ext_data);
/*
* IPC Firmware ready.
*/
static void sof_get_windows(struct snd_sof_dev *sdev)
{
struct sof_ipc_window_elem *elem;
u32 outbox_offset = 0;
u32 stream_offset = 0;
u32 inbox_offset = 0;
u32 outbox_size = 0;
u32 stream_size = 0;
u32 inbox_size = 0;
int window_offset;
int bar;
int i;
if (!sdev->info_window) {
dev_err(sdev->dev, "error: have no window info\n");
return;
}
bar = snd_sof_dsp_get_bar_index(sdev, SOF_FW_BLK_TYPE_SRAM);
if (bar < 0) {
dev_err(sdev->dev, "error: have no bar mapping\n");
return;
}
for (i = 0; i < sdev->info_window->num_windows; i++) {
elem = &sdev->info_window->window[i];
window_offset = snd_sof_dsp_get_window_offset(sdev, elem->id);
if (window_offset < 0) {
dev_warn(sdev->dev, "warn: no offset for window %d\n",
elem->id);
continue;
}
switch (elem->type) {
case SOF_IPC_REGION_UPBOX:
inbox_offset = window_offset + elem->offset;
inbox_size = elem->size;
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
inbox_offset,
elem->size, "inbox",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_DOWNBOX:
outbox_offset = window_offset + elem->offset;
outbox_size = elem->size;
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
outbox_offset,
elem->size, "outbox",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_TRACE:
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
window_offset +
elem->offset,
elem->size, "etrace",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_DEBUG:
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
window_offset +
elem->offset,
elem->size, "debug",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_STREAM:
stream_offset = window_offset + elem->offset;
stream_size = elem->size;
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
stream_offset,
elem->size, "stream",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_REGS:
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
window_offset +
elem->offset,
elem->size, "regs",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
case SOF_IPC_REGION_EXCEPTION:
sdev->dsp_oops_offset = window_offset + elem->offset;
snd_sof_debugfs_io_item(sdev,
sdev->bar[bar] +
window_offset +
elem->offset,
elem->size, "exception",
SOF_DEBUGFS_ACCESS_D0_ONLY);
break;
default:
dev_err(sdev->dev, "error: get illegal window info\n");
return;
}
}
if (outbox_size == 0 || inbox_size == 0) {
dev_err(sdev->dev, "error: get illegal mailbox window\n");
return;
}
snd_sof_dsp_mailbox_init(sdev, inbox_offset, inbox_size,
outbox_offset, outbox_size);
sdev->stream_box.offset = stream_offset;
sdev->stream_box.size = stream_size;
dev_dbg(sdev->dev, " mailbox upstream 0x%x - size 0x%x\n",
inbox_offset, inbox_size);
dev_dbg(sdev->dev, " mailbox downstream 0x%x - size 0x%x\n",
outbox_offset, outbox_size);
dev_dbg(sdev->dev, " stream region 0x%x - size 0x%x\n",
stream_offset, stream_size);
}
/* check for ABI compatibility and create memory windows on first boot */
int sof_fw_ready(struct snd_sof_dev *sdev, u32 msg_id)
{
struct sof_ipc_fw_ready *fw_ready = &sdev->fw_ready;
int offset;
int bar;
int ret;
/* mailbox must be on 4k boundary */
offset = snd_sof_dsp_get_mailbox_offset(sdev);
if (offset < 0) {
dev_err(sdev->dev, "error: have no mailbox offset\n");
return offset;
}
bar = snd_sof_dsp_get_bar_index(sdev, SOF_FW_BLK_TYPE_SRAM);
if (bar < 0) {
dev_err(sdev->dev, "error: have no bar mapping\n");
return -EINVAL;
}
dev_dbg(sdev->dev, "ipc: DSP is ready 0x%8.8x offset 0x%x\n",
msg_id, offset);
/* no need to re-check version/ABI for subsequent boots */
if (!sdev->first_boot)
return 0;
/* copy data from the DSP FW ready offset */
sof_block_read(sdev, bar, offset, fw_ready, sizeof(*fw_ready));
/* make sure ABI version is compatible */
ret = snd_sof_ipc_valid(sdev);
if (ret < 0)
return ret;
/* now check for extended data */
snd_sof_fw_parse_ext_data(sdev, bar, offset +
sizeof(struct sof_ipc_fw_ready));
sof_get_windows(sdev);
return 0;
}
EXPORT_SYMBOL(sof_fw_ready);
/* generic module parser for mmaped DSPs */
int snd_sof_parse_module_memcpy(struct snd_sof_dev *sdev,
struct snd_sof_mod_hdr *module)
{
struct snd_sof_blk_hdr *block;
int count, bar;
u32 offset;
size_t remaining;
dev_dbg(sdev->dev, "new module size 0x%x blocks 0x%x type 0x%x\n",
module->size, module->num_blocks, module->type);
block = (struct snd_sof_blk_hdr *)((u8 *)module + sizeof(*module));
/* module->size doesn't include header size */
remaining = module->size;
for (count = 0; count < module->num_blocks; count++) {
/* check for wrap */
if (remaining < sizeof(*block)) {
dev_err(sdev->dev, "error: not enough data remaining\n");
return -EINVAL;
}
/* minus header size of block */
remaining -= sizeof(*block);
if (block->size == 0) {
dev_warn(sdev->dev,
"warning: block %d size zero\n", count);
dev_warn(sdev->dev, " type 0x%x offset 0x%x\n",
block->type, block->offset);
continue;
}
switch (block->type) {
case SOF_FW_BLK_TYPE_RSRVD0:
case SOF_FW_BLK_TYPE_ROM...SOF_FW_BLK_TYPE_RSRVD14:
continue; /* not handled atm */
case SOF_FW_BLK_TYPE_IRAM:
case SOF_FW_BLK_TYPE_DRAM:
case SOF_FW_BLK_TYPE_SRAM:
offset = block->offset;
bar = snd_sof_dsp_get_bar_index(sdev, block->type);
if (bar < 0) {
dev_err(sdev->dev,
"error: no BAR mapping for block type 0x%x\n",
block->type);
return bar;
}
break;
default:
dev_err(sdev->dev, "error: bad type 0x%x for block 0x%x\n",
block->type, count);
return -EINVAL;
}
dev_dbg(sdev->dev,
"block %d type 0x%x size 0x%x ==> offset 0x%x\n",
count, block->type, block->size, offset);
/* checking block->size to avoid unaligned access */
if (block->size % sizeof(u32)) {
dev_err(sdev->dev, "error: invalid block size 0x%x\n",
block->size);
return -EINVAL;
}
snd_sof_dsp_block_write(sdev, bar, offset,
block + 1, block->size);
if (remaining < block->size) {
dev_err(sdev->dev, "error: not enough data remaining\n");
return -EINVAL;
}
/* minus body size of block */
remaining -= block->size;
/* next block */
block = (struct snd_sof_blk_hdr *)((u8 *)block + sizeof(*block)
+ block->size);
}
return 0;
}
EXPORT_SYMBOL(snd_sof_parse_module_memcpy);
static int check_header(struct snd_sof_dev *sdev, const struct firmware *fw)
{
struct snd_sof_fw_header *header;
/* Read the header information from the data pointer */
header = (struct snd_sof_fw_header *)fw->data;
/* verify FW sig */
if (strncmp(header->sig, SND_SOF_FW_SIG, SND_SOF_FW_SIG_SIZE) != 0) {
dev_err(sdev->dev, "error: invalid firmware signature\n");
return -EINVAL;
}
/* check size is valid */
if (fw->size != header->file_size + sizeof(*header)) {
dev_err(sdev->dev, "error: invalid filesize mismatch got 0x%zx expected 0x%zx\n",
fw->size, header->file_size + sizeof(*header));
return -EINVAL;
}
dev_dbg(sdev->dev, "header size=0x%x modules=0x%x abi=0x%x size=%zu\n",
header->file_size, header->num_modules,
header->abi, sizeof(*header));
return 0;
}
static int load_modules(struct snd_sof_dev *sdev, const struct firmware *fw)
{
struct snd_sof_fw_header *header;
struct snd_sof_mod_hdr *module;
int (*load_module)(struct snd_sof_dev *sof_dev,
struct snd_sof_mod_hdr *hdr);
int ret, count;
size_t remaining;
header = (struct snd_sof_fw_header *)fw->data;
load_module = sof_ops(sdev)->load_module;
if (!load_module)
return -EINVAL;
/* parse each module */
module = (struct snd_sof_mod_hdr *)((u8 *)(fw->data) + sizeof(*header));
remaining = fw->size - sizeof(*header);
/* check for wrap */
if (remaining > fw->size) {
dev_err(sdev->dev, "error: fw size smaller than header size\n");
return -EINVAL;
}
for (count = 0; count < header->num_modules; count++) {
/* check for wrap */
if (remaining < sizeof(*module)) {
dev_err(sdev->dev, "error: not enough data remaining\n");
return -EINVAL;
}
/* minus header size of module */
remaining -= sizeof(*module);
/* module */
ret = load_module(sdev, module);
if (ret < 0) {
dev_err(sdev->dev, "error: invalid module %d\n", count);
return ret;
}
if (remaining < module->size) {
dev_err(sdev->dev, "error: not enough data remaining\n");
return -EINVAL;
}
/* minus body size of module */
remaining -= module->size;
module = (struct snd_sof_mod_hdr *)((u8 *)module
+ sizeof(*module) + module->size);
}
return 0;
}
int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev)
{
struct snd_sof_pdata *plat_data = sdev->pdata;
const char *fw_filename;
int ret;
/* set code loading condition to true */
sdev->code_loading = 1;
/* Don't request firmware again if firmware is already requested */
if (plat_data->fw)
return 0;
fw_filename = kasprintf(GFP_KERNEL, "%s/%s",
plat_data->fw_filename_prefix,
plat_data->fw_filename);
if (!fw_filename)
return -ENOMEM;
ret = request_firmware(&plat_data->fw, fw_filename, sdev->dev);
if (ret < 0) {
dev_err(sdev->dev, "error: request firmware %s failed err: %d\n",
fw_filename, ret);
}
kfree(fw_filename);
return ret;
}
EXPORT_SYMBOL(snd_sof_load_firmware_raw);
int snd_sof_load_firmware_memcpy(struct snd_sof_dev *sdev)
{
struct snd_sof_pdata *plat_data = sdev->pdata;
int ret;
ret = snd_sof_load_firmware_raw(sdev);
if (ret < 0)
return ret;
/* make sure the FW header and file is valid */
ret = check_header(sdev, plat_data->fw);
if (ret < 0) {
dev_err(sdev->dev, "error: invalid FW header\n");
goto error;
}
/* prepare the DSP for FW loading */
ret = snd_sof_dsp_reset(sdev);
if (ret < 0) {
dev_err(sdev->dev, "error: failed to reset DSP\n");
goto error;
}
/* parse and load firmware modules to DSP */
ret = load_modules(sdev, plat_data->fw);
if (ret < 0) {
dev_err(sdev->dev, "error: invalid FW modules\n");
goto error;
}
return 0;
error:
release_firmware(plat_data->fw);
plat_data->fw = NULL;
return ret;
}
EXPORT_SYMBOL(snd_sof_load_firmware_memcpy);
int snd_sof_load_firmware(struct snd_sof_dev *sdev)
{
dev_dbg(sdev->dev, "loading firmware\n");
if (sof_ops(sdev)->load_firmware)
return sof_ops(sdev)->load_firmware(sdev);
return 0;
}
EXPORT_SYMBOL(snd_sof_load_firmware);
int snd_sof_run_firmware(struct snd_sof_dev *sdev)
{
int ret;
int init_core_mask;
init_waitqueue_head(&sdev->boot_wait);
sdev->boot_complete = false;
/* create read-only fw_version debugfs to store boot version info */
if (sdev->first_boot) {
ret = snd_sof_debugfs_buf_item(sdev, &sdev->fw_version,
sizeof(sdev->fw_version),
"fw_version", 0444);
/* errors are only due to memory allocation, not debugfs */
if (ret < 0) {
dev_err(sdev->dev, "error: snd_sof_debugfs_buf_item failed\n");
return ret;
}
}
/* perform pre fw run operations */
ret = snd_sof_dsp_pre_fw_run(sdev);
if (ret < 0) {
dev_err(sdev->dev, "error: failed pre fw run op\n");
return ret;
}
dev_dbg(sdev->dev, "booting DSP firmware\n");
/* boot the firmware on the DSP */
ret = snd_sof_dsp_run(sdev);
if (ret < 0) {
dev_err(sdev->dev, "error: failed to reset DSP\n");
return ret;
}
init_core_mask = ret;
/* now wait for the DSP to boot */
ret = wait_event_timeout(sdev->boot_wait, sdev->boot_complete,
msecs_to_jiffies(sdev->boot_timeout));
if (ret == 0) {
dev_err(sdev->dev, "error: firmware boot failure\n");
snd_sof_dsp_dbg_dump(sdev, SOF_DBG_REGS | SOF_DBG_MBOX |
SOF_DBG_TEXT | SOF_DBG_PCI);
/* after this point FW_READY msg should be ignored */
sdev->boot_complete = true;
return -EIO;
}
dev_info(sdev->dev, "firmware boot complete\n");
/* perform post fw run operations */
ret = snd_sof_dsp_post_fw_run(sdev);
if (ret < 0) {
dev_err(sdev->dev, "error: failed post fw run op\n");
return ret;
}
/* fw boot is complete. Update the active cores mask */
sdev->enabled_cores_mask = init_core_mask;
return 0;
}
EXPORT_SYMBOL(snd_sof_run_firmware);
void snd_sof_fw_unload(struct snd_sof_dev *sdev)
{
/* TODO: support module unloading at runtime */
}
EXPORT_SYMBOL(snd_sof_fw_unload);
|
815316.c | #include "stdlib.h"
struct node {
struct node *next;
int value;
};
struct stack {
struct node *head;
};
struct stack *create_stack()
{
struct stack *stack = malloc(sizeof(struct stack));
if (stack == 0) { abort(); }
stack->head = 0;
return stack;
}
void stack_push(struct stack *stack, int value)
{
struct node *n = malloc(sizeof(struct node));
if (n == 0) { abort(); }
n->next = stack->head;
n->value = value;
stack->head = n;
}
int stack_pop(struct stack *stack)
{
struct node *head = stack->head;
int result = head->value;
stack->head = head->next;
free(head);
return result;
}
struct neq_a_data {
int a;
};
typedef bool int_predicate(void *data, int x);
struct node *nodes_filter(struct node *n, int_predicate *p, void *data)
{
if (n == 0) {
return 0;
} else {
bool keep = p(data, n->value);
if (keep) {
struct node *next = nodes_filter(n->next, p, data);
n->next = next;
return n;
} else {
struct node *next = n->next;
free(n);
struct node *result = nodes_filter(next, p, data);
return result;
}
}
}
void stack_filter(struct stack *stack, int_predicate *p, void *data)
{
struct node *head = nodes_filter(stack->head, p, data);
stack->head = head;
}
void nodes_dispose(struct node *n)
{
if (n != 0) {
nodes_dispose(n->next);
free(n);
}
}
void stack_dispose(struct stack *stack)
{
nodes_dispose(stack->head);
free(stack);
}
bool neq_a(struct neq_a_data *data, int x)
{
bool result = x != data->a;
return result;
}
int read_int();
int main()
{
struct stack *s = create_stack();
stack_push(s, 10);
stack_push(s, 20);
stack_push(s, 30);
int a = read_int();
struct neq_a_data *data = malloc(sizeof(struct neq_a_data));
if (data == 0) abort();
data->a = a;
stack_filter(s, neq_a, data);
free(data);
stack_dispose(s);
return 0;
}
|
220827.c | /*
* Copyright (c) 2015-2019, Renesas Electronics Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of Renesas nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "common.h"
#include "reg_rzg2.h"
#include "boot_init_gpio.h"
static void InitPOSNEG(void);
static void InitIOINTSEL(void);
static void InitOUTDT(void);
static void InitINOUTSEL(void);
void InitGPIO(void)
{
InitPOSNEG();
InitIOINTSEL();
InitOUTDT();
InitINOUTSEL();
}
static void InitPOSNEG(void)
{
*((volatile uint32_t*)GPIO_POSNEG0)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG1)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG2)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG3)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG4)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG5)=0x00000000;
*((volatile uint32_t*)GPIO_POSNEG6)=0x00000000;
}
static void InitIOINTSEL(void)
{
*((volatile uint32_t*)GPIO_IOINTSEL0)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL1)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL2)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL3)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL4)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL5)=0x00000000;
*((volatile uint32_t*)GPIO_IOINTSEL6)=0x00000000;
}
static void InitOUTDT(void)
{
uint32_t product;
product = *((volatile uint32_t*)PRR) & PRR_PRODUCT_MASK;
switch (product)
{
#ifdef RZG2_HIHOPE
case PRR_PRODUCT_G2M:
case PRR_PRODUCT_G2N:
*((volatile uint32_t*)GPIO_OUTDT1)=0x00000000;
*((volatile uint32_t*)GPIO_OUTDT2)=0x00000400;
*((volatile uint32_t*)GPIO_OUTDT3)=0x0000C000;
*((volatile uint32_t*)GPIO_OUTDT5)=0x00000006;
*((volatile uint32_t*)GPIO_OUTDT6)=0x00003880;
break;
#endif /* RZG2_HIHOPE */
#ifdef RZG2_EK874
case PRR_PRODUCT_G2E:
break;
#endif /* RZG2_EK874 */
default:
break;
}
}
static void InitINOUTSEL(void)
{
uint32_t product;
product = *((volatile uint32_t*)PRR) & PRR_PRODUCT_MASK;
switch (product)
{
#ifdef RZG2_HIHOPE
case PRR_PRODUCT_G2M:
case PRR_PRODUCT_G2N:
*((volatile uint32_t*)GPIO_INOUTSEL0)=0x00000000;
*((volatile uint32_t*)GPIO_INOUTSEL1)=0x01000A00;
*((volatile uint32_t*)GPIO_INOUTSEL2)=0x00000400;
*((volatile uint32_t*)GPIO_INOUTSEL3)=0x0000C000;
*((volatile uint32_t*)GPIO_INOUTSEL4)=0x00000000;
*((volatile uint32_t*)GPIO_INOUTSEL5)=0x0000020E;
*((volatile uint32_t*)GPIO_INOUTSEL6)=0x00013880;
break;
#endif /* RZG2_HIHOPE */
#ifdef RZG2_EK874
case PRR_PRODUCT_G2E:
break;
#endif /* RZG2_EK874*/
default:
break;
}
}
|
832450.c | // Esta função recebe um vetor crescente v[0..n-1]
// e um inteiro x e devolve um índice j em 0..n
// tal que v[j-1] < x <= v[j].
int
buscaBinaria2 (int x, int n, int v[]) {
return bb (x, -1, n, v);
}
// Recebe um vetor crescente v[e+1..d-1]
// e um inteiro x tal que v[e] < x <= v[d]
// e devolve um índice j em e+1..d tal que
// v[j-1] < x <= v[j].
static int
bb (int x, int e, int d, int v[])
{
if (e == d-1)
return d;
else
{
int m = (e + d)/2;
if (v[m] < x)
return bb (x, m, d, v);
else
return bb (x, e, m, v);
}
}
|
476311.c | /*
* Copyright (c) 2018-2020, Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*
*/
#include "attestation_ns_tests.h"
#include "psa/initial_attestation.h"
#include "secure_fw/services/initial_attestation/attestation.h"
#include "../attestation_tests_common.h"
#include "../attest_token_test_values.h"
#include "../attest_token_test.h"
static uint8_t token_buffer[TEST_TOKEN_SIZE];
static const uint8_t challenge_buffer[TEST_CHALLENGE_OBJ_SIZE] = {
TOKEN_TEST_NONCE_BYTES};
/* Define test suite for attestation service tests */
/* List of tests */
#ifdef INCLUDE_TEST_CODE /* Remove them from release build */
static void tfm_attest_test_2001(struct test_result_t *ret);
static void tfm_attest_test_2002(struct test_result_t *ret);
static void tfm_attest_test_2003(struct test_result_t *ret);
#endif
static void tfm_attest_test_2004(struct test_result_t *ret);
static void tfm_attest_test_2005(struct test_result_t *ret);
static struct test_t attestation_interface_tests[] = {
#ifdef INCLUDE_TEST_CODE /* Remove them from release build */
{&tfm_attest_test_2001, "TFM_ATTEST_TEST_2001",
"Minimal token test of attest token", {0} },
{&tfm_attest_test_2002, "TFM_ATTEST_TEST_2002",
"Minimal token size test of attest token", {0} },
{&tfm_attest_test_2003, "TFM_ATTEST_TEST_2003",
"Short circuit signature test of attest token", {0} },
#endif
{&tfm_attest_test_2004, "TFM_ATTEST_TEST_2004",
"ECDSA signature test of attest token", {0} },
{&tfm_attest_test_2005, "TFM_ATTEST_TEST_2005",
"Negative test cases for initial attestation service", {0} },
};
void
register_testsuite_ns_attestation_interface(struct test_suite_t *p_test_suite)
{
uint32_t list_size;
list_size = (sizeof(attestation_interface_tests) /
sizeof(attestation_interface_tests[0]));
set_testsuite("Initial Attestation Service non-secure interface tests"
"(TFM_ATTEST_TEST_2XXX)",
attestation_interface_tests, list_size, p_test_suite);
}
#ifdef INCLUDE_TEST_CODE /* Remove them from release build */
/*!
* \brief Get minimal token, only include a hard coded challenge, but omit the
* rest of the claims
*
* Calling the minimal_test, which just retrieves a specific token:
* - only hard coded challenge is included
* - token signature is the hash of the token concatenated twice
*/
static void tfm_attest_test_2001(struct test_result_t *ret)
{
int32_t err;
err = minimal_test();
if (err != 0) {
TEST_LOG("minimal_test() returned: %d\r\n", err);
TEST_FAIL("Attest token minimal_test() has failed");
return;
}
ret->val = TEST_PASSED;
}
/*!
* \brief Get the size of the minimal token, only include a hard coded
* challenge, but omit the rest of the claims
*/
static void tfm_attest_test_2002(struct test_result_t *ret)
{
int32_t err;
err = minimal_get_size_test();
if (err != 0) {
TEST_LOG("minimal_get_size_test() returned: %d\r\n", err);
TEST_FAIL("Attest token minimal_get_size_test() has failed");
return;
}
ret->val = TEST_PASSED;
}
/*!
* \brief Get an IAT with short circuit signature (signature is composed of
* hash of token). Parse the token, validate presence of claims and
* compare them against expected values in token_test_values.h
*
* More info in token_test.h
*/
static void tfm_attest_test_2003(struct test_result_t *ret)
{
int32_t err;
err = decode_test_short_circuit_sig();
if (err != 0) {
TEST_LOG("decode_test_short_circuit_sig() returned: %d\r\n", err);
TEST_FAIL("Attest token decode_test_short_circuit_sig() has failed");
return;
}
ret->val = TEST_PASSED;
}
#endif /* INCLUDE_TEST_CODE */
/*!
* \brief Get an IAT with proper ECDSA signature. Parse the token, validate
* presence of claims and compare them against expected values in
* token_test_values.h
*
* ECDSA signing is currently not supported in TF_M.
*
* More info in token_test.h
*/
static void tfm_attest_test_2004(struct test_result_t *ret)
{
int32_t err;
err = decode_test_normal_sig();
if (err != 0) {
TEST_LOG("decode_test_normal_sig() returned: %d\r\n", err);
TEST_FAIL("Attest token decode_test_normal_sig() has failed");
return;
}
ret->val = TEST_PASSED;
}
/*!
* \brief Negative tests for initial attestation service
*
* - Calling initial attestation service with bigger challenge object than
* allowed.
* - Calling initial attestation service with smaller buffer size than the
* expected size of the token.
*/
static void tfm_attest_test_2005(struct test_result_t *ret)
{
psa_status_t err;
size_t token_buf_size = TEST_TOKEN_SIZE;
size_t token_size;
/* Call with with bigger challenge object than allowed */
err = psa_initial_attest_get_token(challenge_buffer,
INVALID_CHALLENGE_OBJECT_SIZE,
token_buffer,
token_buf_size,
&token_size);
if (err != PSA_ERROR_INVALID_ARGUMENT) {
TEST_FAIL("Attestation should fail with too big challenge object");
return;
}
/* Call with smaller buffer size than size of test token */
token_buf_size = TOO_SMALL_TOKEN_BUFFER;
err = psa_initial_attest_get_token(challenge_buffer,
TEST_CHALLENGE_OBJ_SIZE,
token_buffer,
token_buf_size,
&token_size);
if (err != PSA_ERROR_BUFFER_TOO_SMALL) {
TEST_FAIL("Attestation should fail with too small token buffer");
return;
}
ret->val = TEST_PASSED;
}
|
451457.c | /*******************************************************************************************
Cyber Tank HW (c) 1987 Coreland Technology
WIP driver by Angelo Salese
- Communications
Master slave comms looks like shared RAM.
The slave tests these RAM banks all using the same routine at 0x000006E6
There are also routines for clearing each bank of RAM after POST,
including the shared RAM (0x).
The amount cleared in each bank is different than the amount tested.
IC20 (7D0*2 bytes starting @ 0x080000, code at 0x00000684) \ Tested as 0xFA0 (4000) bytes.
IC21 (7D0*2 bytes starting @ 0x080001, code at 0x00000690) / Cleared at 0x0000042a as 0x1000 bytes.
IC22 (1F4*2 bytes starting @ 0x0c0000, code at 0x0000069E) \ Tested as 0x3e8 (1000) bytes.
IC23 (1F4*2 bytes starting @ 0x0c0001, code at 0x000006AA) / Cleared at 0x00000440 as 0x4000 bytes.
IC24 (1F4*2 bytes starting @ 0x100001, code at 0x000006B8) > Shared RAM
The shared ram is tested and cleared almost the same as the other RAM,
and is mapped into the master at E0000. Only every odd byte is used.
The first 0x10 bytes are used heavily as registers
during the POST, key ones are
share_0001 hold - slave waits for this to be cleared.
share_0009 master cmd to slave
share_0011 slave status
share_000b bit mask of failed ICs returned to master, defaults to all failed.
There are also block writes carried out by the slave every
second irq 3. The data transfer area appears to start at 0x100021.
Master reads at 0x00005E3C
It is tested as every odd byte from 0x100021 to 0x1003e8,
and cleared as every odd byte from 0x100021 up to 0x100fff)
- Missing ROM data
IC03 and IC04 are missing from the set.
These look like "logical" ICs rather that physical ones.
The main program code is dumped as 2x128k files p1a and p2a.
The checksum routine does 4x64k checks, going by the routine.
IC01 is the first half of p1a, IC02 is the first half of p2a,
IC03 is the second half of p1a and IC04 is the second half of p2a.
IC01 FEFF bytes @ 0x00200 code at 0x000019FE CHKSUM A5 (00200 offset is just after where the checksum is recorded)
IC02 FEFF bytes @ 0x00201 code at 0x00001A24 CHKSUM 87
IC03 FFFF bytes @ 0x20000 code at 0x00001A46 CHKSUM 61
IC04 FFFF bytes @ 0x20001 code at 0x00001A6A CHKSUM E0
Unfortunately the second half of p1a and p2a are empty, all 0xff.
No other ROMs in the entire set match the checksums used in the POST.
I am guessing they are bad dumps.
- Unmapped reads/writes
CPU1 reads at 0x07fff8 and 0x07fffa are the slave reading validation values
to compare to slave program ROM checksums.
The test will never fail, the results of the comparison are ignored by the code,
so there may never have been an implementation.
CPU1 unmapped read at 0x20000 is a checksum overrun by a single loop iteration.
See loop at 0x000006D2, it's a "do while" loop that tests loop after testing ROM.
Unmapped read/write by CPU2 of 0xa005, 0xa006 This looks like loop overrun too,
or maybe caused by the initial base offset which is the same as the loop increments it.
Sub at CPU2:01B7, the block process starts at base 8020h and increments by 20h each time.
It overruns the top of RAM on the last iteration.
TODO:
-Rom "SS5" is missing?Or it's a sound chip that's labelled SS5?
-Paletteram is likely to be buffered,the two banks are really similar.
============================================================================================
Cyber Tank
Coreland Technology, Inc 1987
---------------------
BA87015
SS2 -
SS4 SS3
- -
- SS1
Y8950 Y8950
2064
SS5
Z80B
3.5795MHz
---------------------
BA87035
68000-10 20MHz 68000-10
SUBH SUBL P2A P1A
2064 2064 2064 2064
C04 C03 C02 C01
C08 C07 C06 C05
C12 C11 C10 C09
C16 C15 C14 C13 2016
2016
W31003
SW1 SW2 SW3
---------------------
BA87034
T2 T1 43256 43256
IC19 IC20 43256 43256
IC29 IC30
43256 43256
43256 43256
43256 43256
T3 43256 43256
T4
43256 43256
43256 43256
W31004
W31004
----------------------
BA87033
22.8MHz IC2 2016 W31001
IC15 2016 W31004
ROAD_CHL
ROAD_CHH
S01
2064 S02
2064 S03 T6 T5
W31002 2064 S04 W31004
S05
S06
2064 S07 2064 2064
2064 2064 S08 W31004 2064 2064
W31002
S09
2064 S10
2064 S11
W31002 2064 S12 W31004
VID1CONN VID2CONN
********************************************************************************************
M68k Master irq table:
lev 1 : 0x64 : 0000 0870 - vblank
lev 2 : 0x68 : 0000 0caa - input device clear?
lev 3 : 0x6c : 0000 0caa - input device clear?
lev 4 : 0x70 : 0000 0caa - input device clear?
lev 5 : 0x74 : 0000 0caa - input device clear?
lev 6 : 0x78 : 0000 0caa - input device clear?
lev 7 : 0x7c : ffff ffff - illegal
M68k Slave irq table:
lev 1 : 0x64 : 0000 07e0 - input device clear?
lev 2 : 0x68 : 0000 07e0 - input device clear?
lev 3 : 0x6c : 0000 0764 - vblank?
lev 4 : 0x70 : 0000 07e0 - input device clear?
lev 5 : 0x74 : 0000 07e0 - input device clear?
lev 6 : 0x78 : 0000 07e0 - input device clear?
lev 7 : 0x7c : 0000 07e0 - input device clear?
*******************************************************************************************/
#include "driver.h"
#include "cpu/z80/z80.h"
#include "cpu/m68000/m68000.h"
#include "deprecat.h"
#include "sound/8950intf.h"
static tilemap *tx_tilemap;
static UINT16 *tx_vram;
static UINT16 *shared_ram;
static UINT16 *io_ram;
#define LOG_UNKNOWN_WRITE logerror("unknown io write CPU '%s':%08x 0x%08x 0x%04x & 0x%04x\n", space->cpu->tag, cpu_get_pc(space->cpu), offset*2, data, mem_mask);
#define IGNORE_MISSING_ROM 1
static TILE_GET_INFO( get_tx_tile_info )
{
int code = tx_vram[tile_index];
SET_TILE_INFO(
0,
code & 0x1fff,
(code & 0xe000) >> 13,
0);
}
static VIDEO_START( cybertnk )
{
tx_tilemap = tilemap_create(machine, get_tx_tile_info,tilemap_scan_rows,8,8,128,32);
}
static VIDEO_UPDATE( cybertnk )
{
tilemap_draw(bitmap,cliprect,tx_tilemap,0,0);
return 0;
}
static DRIVER_INIT( cybertnk )
{
#ifdef IGNORE_MISSING_ROM
UINT16 *ROM = (UINT16*)memory_region(machine, "maincpu");
/* nop the rom checksum branch */
ROM[0x1546/2] = 0x4e71;
ROM[0x1548/2] = 0x4e71;
ROM[0x154a/2] = 0x4e71;
ROM[0x154c/2] = 0x4e71;
#endif
}
static WRITE16_HANDLER( tx_vram_w )
{
COMBINE_DATA(&tx_vram[offset]);
tilemap_mark_tile_dirty(tx_tilemap,offset);
}
static WRITE16_HANDLER( share_w )
{
COMBINE_DATA(&shared_ram[offset]);
}
static READ16_HANDLER( share_r )
{
return shared_ram[offset];
}
static READ16_HANDLER( io_r )
{
switch( offset )
{
case 2/2:
return input_port_read(space->machine, "DSW1");
// 0x00110007 is controller device select
// 0x001100D5 is controller data
// 0x00110004 low is controller data ready
case 4/2:
switch( (io_ram[7/2]) & 0xff )
{
case 0:
io_ram[0xd5/2] = input_port_read(space->machine, "TRAVERSE");
break;
case 0x20:
io_ram[0xd5/2] = input_port_read(space->machine, "ELEVATE");
break;
case 0x40:
io_ram[0xd5/2] = input_port_read(space->machine, "ACCEL");
break;
case 0x42:
// only once I think, during init at 0x00000410
// controller return value is stored in $42(a6)
// but I don't see it referenced again.
popmessage("unknown controller device 0x42");
io_ram[0xd5/2] = 0;
break;
case 0x60:
io_ram[0xd5/2] = input_port_read(space->machine, "HANDLE");
break;
default:
popmessage("unknown controller device");
}
return 0;
case 6/2:
return input_port_read(space->machine, "IN0"); // high half
case 9/2:
return input_port_read(space->machine, "IN0"); // low half
case 0xb/2:
return input_port_read(space->machine, "DSW2");
case 0xd5/2:
return io_ram[offset]; // controller data
default:
{
popmessage("unknown io read 0x%08x", offset);
return io_ram[offset];
}
}
}
static WRITE16_HANDLER( io_w )
{
COMBINE_DATA(&io_ram[offset]);
switch( offset*2 )
{
case 0:
// sound data
if (ACCESSING_BITS_0_7)
cputag_set_input_line(space->machine, "audiocpu", 0, HOLD_LINE);
else
LOG_UNKNOWN_WRITE
break;
case 2:
if (ACCESSING_BITS_0_7)
;//watchdog ? written in similar context to CPU1 @ 0x140002
else
LOG_UNKNOWN_WRITE
break;
case 6:
if (ACCESSING_BITS_0_7)
;//select controller device
else
;//blank inputs
break;
case 8:
if (ACCESSING_BITS_8_15)
;//blank inputs
else
LOG_UNKNOWN_WRITE
break;
case 0xc:
if (ACCESSING_BITS_0_7)
// This seems to only be written after each irq1 and irq2
logerror("irq wrote %04x\n", data);
else
LOG_UNKNOWN_WRITE
break;
case 0xd4:
if ( ACCESSING_BITS_0_7 )
;// controller device data
else
LOG_UNKNOWN_WRITE
break;
// Cabinet pictures show dials and gauges
// Maybe this is for lamps and stuff, or
// maybe just debug.
// They are all written in a block at 0x00000944
case 0x42:
case 0x44:
case 0x48:
case 0x4a:
case 0x4c:
case 0x80:
case 0x82:
case 0x84:
break;
default:
LOG_UNKNOWN_WRITE
break;
}
}
static READ8_HANDLER( soundport_r )
{
return io_ram[0] & 0xff;
}
static ADDRESS_MAP_START( master_mem, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x000000, 0x03ffff) AM_ROM
AM_RANGE(0x080000, 0x087fff) AM_RAM /*Work RAM*/
AM_RANGE(0x0a0000, 0x0a0fff) AM_RAM
AM_RANGE(0x0c0000, 0x0c3fff) AM_RAM_WRITE(tx_vram_w) AM_BASE(&tx_vram)
AM_RANGE(0x0c4000, 0x0cffff) AM_RAM
AM_RANGE(0x0e0000, 0x0e0fff) AM_READWRITE(share_r, share_w) AM_BASE(&shared_ram)
AM_RANGE(0x100000, 0x107fff) AM_RAM_WRITE(paletteram16_xBBBBBGGGGGRRRRR_word_w) AM_BASE(&paletteram16)
AM_RANGE(0x110000, 0x1101ff) AM_READWRITE(io_r,io_w) AM_BASE(&io_ram)
ADDRESS_MAP_END
static ADDRESS_MAP_START( slave_mem, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x000000, 0x01ffff) AM_ROM
AM_RANGE(0x080000, 0x083fff) AM_RAM /*Work RAM*/
AM_RANGE(0x0c0000, 0x0c3fff) AM_RAM
AM_RANGE(0x100000, 0x100fff) AM_READWRITE(share_r, share_w)
AM_RANGE(0x140002, 0x140003) AM_NOP /*Watchdog? Written during loops and interrupts*/
ADDRESS_MAP_END
static ADDRESS_MAP_START( sound_mem, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x0000, 0x7fff ) AM_ROM
AM_RANGE(0x8000, 0x9fff ) AM_RAM
AM_RANGE(0xa001, 0xa001 ) AM_READ(soundport_r)
AM_RANGE(0xa000, 0xa001 ) AM_DEVREADWRITE("ym1", y8950_r, y8950_w)
AM_RANGE(0xc000, 0xc001 ) AM_DEVREADWRITE("ym2", y8950_r, y8950_w)
ADDRESS_MAP_END
static INPUT_PORTS_START( cybertnk )
PORT_START("IN0")
PORT_BIT( 0x0001, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0002, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0004, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0008, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0010, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0020, IP_ACTIVE_LOW, IPT_UNUSED )
PORT_BIT( 0x0040, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(1) // MG 1
PORT_BIT( 0x0080, IP_ACTIVE_LOW, IPT_BUTTON3 ) PORT_PLAYER(1) // Cannon 1
PORT_BIT( 0x0100, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(2) // MG 2
PORT_BIT( 0x0200, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(2) // Cannon 2
PORT_BIT( 0x0400, IP_ACTIVE_LOW, IPT_SERVICE1 )
PORT_SERVICE_NO_TOGGLE( 0x0800, IP_ACTIVE_LOW )
PORT_BIT( 0x1000, IP_ACTIVE_LOW, IPT_START2 )
PORT_BIT( 0x2000, IP_ACTIVE_LOW, IPT_START1 )
PORT_BIT( 0x4000, IP_ACTIVE_LOW, IPT_COIN2 )
PORT_BIT( 0x8000, IP_ACTIVE_LOW, IPT_COIN1 )
PORT_START("TRAVERSE")
PORT_BIT( 0xff, 0x00, IPT_MOUSE_X ) PORT_MINMAX(0x00,0xff) PORT_SENSITIVITY(100) PORT_KEYDELTA(20) PORT_PLAYER(2)
PORT_START("ELEVATE")
PORT_BIT( 0xff, 0x00, IPT_MOUSE_Y ) PORT_MINMAX(0x00,0xff) PORT_SENSITIVITY(100) PORT_KEYDELTA(20) PORT_PLAYER(2)
PORT_START("ACCEL")
PORT_BIT( 0xff, 0x00, IPT_PEDAL ) PORT_MINMAX(0x00,0xff) PORT_SENSITIVITY(100) PORT_KEYDELTA(20) PORT_PLAYER(1)
PORT_START("HANDLE")
PORT_BIT( 0xff, 0x7f, IPT_PADDLE ) PORT_MINMAX(0x00,0xff) PORT_SENSITIVITY(100) PORT_KEYDELTA(4) PORT_PLAYER(1)
PORT_START("DSW1")
PORT_DIPNAME( 0x0001, 0x0001, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:8")
PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0002, 0x0002, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:7")
PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0004, 0x0004, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:6")
PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0008, 0x0008, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:5")
PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0010, 0x0010, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:4")
PORT_DIPSETTING( 0x0010, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0020, 0x0020, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:3")
PORT_DIPSETTING( 0x0020, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0040, 0x0040, DEF_STR( Test ) ) PORT_DIPLOCATION("SW2:2")
PORT_DIPSETTING( 0x0040, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0080, 0x0080, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW2:1")
PORT_DIPSETTING( 0x0080, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0100, 0x0100, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:8")
PORT_DIPSETTING( 0x0100, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0200, 0x0200, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:7")
PORT_DIPSETTING( 0x0200, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0400, 0x0400, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:6")
PORT_DIPSETTING( 0x0400, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0800, 0x0800, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:5")
PORT_DIPSETTING( 0x0800, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x1000, 0x1000, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:4")
PORT_DIPSETTING( 0x1000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x2000, 0x2000, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:3")
PORT_DIPSETTING( 0x2000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x4000, 0x4000, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:2")
PORT_DIPSETTING( 0x4000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x8000, 0x8000, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW1:1")
PORT_DIPSETTING( 0x8000, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_START("DSW2")
PORT_DIPNAME( 0x0001, 0x0001, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:8")
PORT_DIPSETTING( 0x0001, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0002, 0x0002, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:7")
PORT_DIPSETTING( 0x0002, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0004, 0x0004, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:6")
PORT_DIPSETTING( 0x0004, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0008, 0x0008, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:5")
PORT_DIPSETTING( 0x0008, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0010, 0x0010, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:4")
PORT_DIPSETTING( 0x0010, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0020, 0x0020, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:3")
PORT_DIPSETTING( 0x0020, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0040, 0x0040, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:2")
PORT_DIPSETTING( 0x0040, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_DIPNAME( 0x0080, 0x0080, DEF_STR( Unknown ) ) PORT_DIPLOCATION("SW3:1")
PORT_DIPSETTING( 0x0080, DEF_STR( Off ) )
PORT_DIPSETTING( 0x0000, DEF_STR( On ) )
PORT_BIT( 0xff00, IP_ACTIVE_LOW, IPT_UNUSED )
INPUT_PORTS_END
static const gfx_layout tile_8x8x4 =
{
8,8,
RGN_FRAC(1,4),
4,
{ RGN_FRAC(0,4),RGN_FRAC(1,4),RGN_FRAC(2,4),RGN_FRAC(3,4) },
{ STEP8(0,1) },
{ STEP8(0,8) },
8*8
};
static const gfx_layout tile_16x16x4 =
{
16,16,
RGN_FRAC(1,4),
4,
{ RGN_FRAC(0,4),RGN_FRAC(1,4),RGN_FRAC(2,4),RGN_FRAC(3,4) },
{ STEP16(0,1) },
{ STEP16(0,16) },
32*8
};
static GFXDECODE_START( cybertnk )
GFXDECODE_ENTRY( "gfx1", 0, tile_8x8x4, 0x1400, 16 ) /*Pal offset???*/
GFXDECODE_ENTRY( "gfx2", 0, tile_8x8x4, 0, 0x400 )
GFXDECODE_ENTRY( "gfx2", 0, tile_16x16x4, 0, 0x400 )
GFXDECODE_ENTRY( "gfx3", 0, tile_8x8x4, 0, 0x400 )
GFXDECODE_ENTRY( "gfx3", 0, tile_16x16x4, 0, 0x400 )
GFXDECODE_END
static INTERRUPT_GEN( master_irq )
{
switch(cpu_getiloops(device))
{
case 0: cpu_set_input_line(device,1,HOLD_LINE); break;
case 1: cpu_set_input_line(device,3,HOLD_LINE); break;
}
}
static INTERRUPT_GEN( slave_irq )
{
switch(cpu_getiloops(device))
{
case 0: cpu_set_input_line(device,3,HOLD_LINE); break;
case 1: cpu_set_input_line(device,1,HOLD_LINE); break;
}
}
static const y8950_interface y8950_config = {
0 /* TODO */
};
static MACHINE_DRIVER_START( cybertnk )
MDRV_CPU_ADD("maincpu", M68000,20000000/2)
MDRV_CPU_PROGRAM_MAP(master_mem)
MDRV_CPU_VBLANK_INT_HACK(master_irq,2)
MDRV_CPU_ADD("slave", M68000,20000000/2)
MDRV_CPU_PROGRAM_MAP(slave_mem)
MDRV_CPU_VBLANK_INT_HACK(slave_irq,2)
MDRV_CPU_ADD("audiocpu", Z80,3579500)
MDRV_CPU_PROGRAM_MAP(sound_mem)
MDRV_QUANTUM_TIME(HZ(6000))//arbitrary value,needed to get the communication to work
/* video hardware */
MDRV_SCREEN_ADD("screen", RASTER)
MDRV_SCREEN_REFRESH_RATE(60)
MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
MDRV_SCREEN_SIZE(64*8, 32*8)
MDRV_SCREEN_VISIBLE_AREA(0*8, 64*8-1, 2*8, 32*8-1)
MDRV_GFXDECODE(cybertnk)
MDRV_PALETTE_LENGTH(0x4000)
MDRV_VIDEO_START(cybertnk)
MDRV_VIDEO_UPDATE(cybertnk)
/* sound hardware */
MDRV_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
MDRV_SOUND_ADD("ym1", Y8950, 3579500)
MDRV_SOUND_CONFIG(y8950_config)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
MDRV_SOUND_ADD("ym2", Y8950, 3579500)
MDRV_SOUND_CONFIG(y8950_config)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
MDRV_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
MACHINE_DRIVER_END
/***************************************************************************
Game driver(s)
***************************************************************************/
ROM_START( cybertnk )
ROM_REGION( 0x80000, "maincpu", 0 )
ROM_LOAD16_BYTE( "p1a", 0x00000, 0x20000, BAD_DUMP CRC(de7ff83a) SHA1(64a34443b532db24ec2c86f0e288eaf12a2212af) )
ROM_LOAD16_BYTE( "p2a", 0x00001, 0x20000, BAD_DUMP CRC(9b6afa26) SHA1(387a6eb6e5da9752869fcc6433cc7516a28d6d30) )
ROM_REGION( 0x20000, "slave", 0 )
ROM_LOAD16_BYTE( "subl", 0x00000, 0x10000, CRC(3814a2eb) SHA1(252800b21f5cfada34ef5208cda33088daab132b) )
ROM_LOAD16_BYTE( "subh", 0x00001, 0x10000, CRC(1af7ad58) SHA1(450c65289729d74cd4d17e11be16469246e61b7d) )
ROM_REGION( 0x8000, "audiocpu", 0 )
ROM_LOAD( "ss1", 0x0000, 0x8000, CRC(c3ba160b) SHA1(cfbfcad443ff83cd4e707f045a650417aca03d85) )
ROM_REGION( 0x80000, "ym1", 0 )
ROM_LOAD( "ss2", 0x00000, 0x20000, CRC(da4b8733) SHA1(177372a53fd49629d1cda83bdd324ee90fbcdbb5) )
/*The following two are identical*/
ROM_LOAD( "ss3", 0x20000, 0x20000, CRC(cecdea53) SHA1(7e6a6499cab4720f4b6d6d8988bb9dd5766511ab) )
ROM_LOAD( "ss4", 0x40000, 0x20000, CRC(cecdea53) SHA1(7e6a6499cab4720f4b6d6d8988bb9dd5766511ab) )
//ss5?
ROM_REGION( 0x80000, "ym2", 0 )
ROM_LOAD( "ss2", 0x00000, 0x20000, CRC(da4b8733) SHA1(177372a53fd49629d1cda83bdd324ee90fbcdbb5) )
/*The following two are identical*/
ROM_LOAD( "ss3", 0x20000, 0x20000, CRC(cecdea53) SHA1(7e6a6499cab4720f4b6d6d8988bb9dd5766511ab) )
ROM_LOAD( "ss4", 0x40000, 0x20000, CRC(cecdea53) SHA1(7e6a6499cab4720f4b6d6d8988bb9dd5766511ab) )
//ss5?
ROM_REGION( 0x40000, "gfx1", 0 )
ROM_LOAD( "s09", 0x00000, 0x10000, CRC(69e6470c) SHA1(8e7db6988366cae714fff72449623a7977af1db1) )
ROM_LOAD( "s10", 0x10000, 0x10000, CRC(77230f44) SHA1(b79fc841fa784d23855e4085310cee435c11348f) )
ROM_LOAD( "s11", 0x20000, 0x10000, CRC(bfda980d) SHA1(1f975fdd2cfdc345eeb03fbc26fc1be1b2d7737e) )
ROM_LOAD( "s12", 0x30000, 0x10000, CRC(8a11fcfa) SHA1(a406ac9cf841dd9d829cb83bfe8feb5128a3e77e) )
ROM_REGION( 0x40000, "gfx2", 0 )
ROM_LOAD( "s01", 0x00000, 0x10000, CRC(6513452c) SHA1(95ed2da8f90e16c50716011577606a7dc93ba65e) )
ROM_LOAD( "s02", 0x10000, 0x10000, CRC(3a270e3b) SHA1(97c8282d4d782c9d2fcfb5e5dabbe1ca88978f5c) )
ROM_LOAD( "s03", 0x20000, 0x10000, CRC(584eff66) SHA1(308ec058693ce3ce34b058a8dbeedf342134311c) )
ROM_LOAD( "s04", 0x30000, 0x10000, CRC(51ba5402) SHA1(c4522c4562ce0514bef3257e323bcc255b635544) )
ROM_REGION( 0x40000, "gfx3", 0 )
ROM_LOAD( "s05", 0x00000, 0x10000, CRC(bddb6008) SHA1(bacb822bac4893eee0648a19ce449e5559d32b5e) )
ROM_LOAD( "s06", 0x10000, 0x10000, CRC(d65b0fa5) SHA1(ce398a52ad408778fd910c42a9618194b862becf) )
ROM_LOAD( "s07", 0x20000, 0x10000, CRC(70220567) SHA1(44b48ded8581a6d78b27a3af833f62413ff31c76) )
ROM_LOAD( "s08", 0x30000, 0x10000, CRC(988c4fcb) SHA1(68d32be70605ad5415f2b6aeabbd92e269f0c9af) )
/*The following ROM regions aren't checked yet*/
ROM_REGION( 0x200000, "user1", 0 )
ROM_LOAD( "c01" , 0x000000, 0x20000, CRC(f7021069) SHA1(67835750f39effd362ccaee381765afce8fa16b2) )
ROM_LOAD( "c02" , 0x020000, 0x20000, CRC(665e193c) SHA1(12c116da0a2d4e881d8598727ff63299fb98c6d2) )
ROM_LOAD( "c03" , 0x040000, 0x20000, CRC(f230d700) SHA1(60fdba4b0fe4df5507e999bed917da93c6cd9a9c) )
ROM_LOAD( "c04" , 0x060000, 0x20000, CRC(999fd57d) SHA1(3e8b8dac595555419831784a27f95420e10b58bd) )
ROM_LOAD( "c05" , 0x080000, 0x20000, CRC(9bafb49c) SHA1(6deddbaa44c8e11e0ac73a5330935a9a260b5d43) )
ROM_LOAD( "c06" , 0x0a0000, 0x20000, CRC(e60de7a2) SHA1(9daa820eefddf079e3940341acc316b1f19ba7ed) )
ROM_LOAD( "c07" , 0x0c0000, 0x20000, CRC(e7cf992a) SHA1(610b2c78a16d8a9d420b1513e2dcfa693f1d8b42) )
ROM_LOAD( "c08" , 0x0e0000, 0x20000, CRC(ce0343b9) SHA1(ef511a04709c49250b32c5b47a6f5024af8acc5b) )
ROM_LOAD( "c09" , 0x100000, 0x20000, CRC(63a443d1) SHA1(9c0fdca3f8e65dc984ec3c089b379c5a61066630) )
ROM_LOAD( "c10" , 0x120000, 0x20000, CRC(01331635) SHA1(8af7fbe2609b6d96bcd63d884cf92095593130ff) )
ROM_LOAD( "c11" , 0x140000, 0x20000, CRC(d46ccfa3) SHA1(c872bc5a25f0b574cb2f9d3b1dff36c3eff751b4) )
ROM_LOAD( "c12" , 0x160000, 0x20000, CRC(c3c39c4a) SHA1(93f3572dd62ef7a92044345249efb0d9ec99bdf9) )
ROM_LOAD( "c13" , 0x180000, 0x20000, CRC(0f366b92) SHA1(2361ac9b1309d5fbd1dec93ca5aecdf45deaeaed) )
ROM_LOAD( "c14" , 0x1a0000, 0x20000, CRC(406d5a0d) SHA1(51e4e85d9c63ef687671fbb213b14d66930070ce) )
ROM_LOAD( "c15" , 0x1c0000, 0x20000, CRC(ad681c70) SHA1(84c6589464103091b39f1ccdbfed10bf538452f3) )
ROM_LOAD( "c16" , 0x1e0000, 0x20000, CRC(1f44dbb6) SHA1(ea1368d6367a2de6d5e6764f8ab705b182d6d276) )
ROM_REGION( 0x200000, "user2", 0 )
ROM_LOAD16_BYTE( "road_chl" , 0x000000, 0x20000, CRC(862b109c) SHA1(9f81918362218ddc0a6bf0a5317c5150e514b699) )
ROM_LOAD16_BYTE( "road_chh" , 0x000001, 0x20000, CRC(9dedc988) SHA1(10bae1be0e35320872d4994f7e882cd1de988c90) )
ROM_REGION( 0x30000, "user3", 0 )
ROM_LOAD( "t1", 0x00000, 0x08000, CRC(24890512) SHA1(2a6c9d39ca0c1c8316e85d9f565f6b3922d596b2) )
ROM_LOAD( "t2", 0x08000, 0x08000, CRC(5a10480d) SHA1(f17598442091dae14abe3505957d94793f3ed886))
ROM_LOAD( "t3", 0x10000, 0x08000, CRC(454af4dc) SHA1(e5b18a37715e50db2243432564f5a04fb39dea60) )
ROM_LOAD( "t4", 0x18000, 0x08000, CRC(0e1ef6a9) SHA1(d230841bbee6d07bab05aa8d37ec2409fc6278bc) )
/*The following two are identical*/
ROM_LOAD( "t5", 0x20000, 0x08000, CRC(12eb51bc) SHA1(35708eb456207ebee498c70dd82340b364797c56) )
ROM_LOAD( "t6", 0x28000, 0x08000, CRC(12eb51bc) SHA1(35708eb456207ebee498c70dd82340b364797c56) )
ROM_REGION( 0x280, "proms", 0 )
ROM_LOAD( "ic2", 0x0000, 0x0100, CRC(aad2a447) SHA1(a12923027e3093bd6d358af44d35d2e8e588dd1a) )//road proms related?
ROM_LOAD( "ic15", 0x0100, 0x0100, CRC(5f8c2c00) SHA1(50162503ac0ee9395377d7e45a84672a9493fb7d) )
ROM_LOAD( "ic19", 0x0200, 0x0020, CRC(bd15cd71) SHA1(e0946d12eebd5db8707d965be157914d70f7472b) )//T1-T6 proms related?
ROM_LOAD( "ic20", 0x0220, 0x0020, CRC(2f237563) SHA1(b0081c1cc6e357a6f10ab1ff357bd4e989ec7fb3) )
ROM_LOAD( "ic29", 0x0240, 0x0020, CRC(95b32c0f) SHA1(5a19f441ced983bacbf3bc1aaee94ca768166447) )
ROM_LOAD( "ic30", 0x0260, 0x0020, CRC(2bb6033f) SHA1(eb994108734d7d04f8e293eca21bb3051a63cfe9) )
ROM_END
GAME( 1990, cybertnk, 0, cybertnk, cybertnk, cybertnk, ROT0, "Coreland", "Cyber Tank (v1.04)", GAME_NO_SOUND|GAME_NOT_WORKING )
|
611605.c | /* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
#include "sdk_common.h"
#if NRF_MODULE_ENABLED(SAADC)
#include "nrf_drv_saadc.h"
#include "nrf_assert.h"
#include "nrf_drv_common.h"
#include "app_util_platform.h"
#define NRF_LOG_MODULE_NAME "SAADC"
#if SAADC_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL SAADC_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR SAADC_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR SAADC_CONFIG_DEBUG_COLOR
#define EVT_TO_STR(event) (event == NRF_SAADC_EVENT_STARTED ? "NRF_SAADC_EVENT_STARTED" : \
(event == NRF_SAADC_EVENT_END ? "NRF_SAADC_EVENT_END" : \
(event == NRF_SAADC_EVENT_DONE ? "NRF_SAADC_EVENT_DONE" : \
(event == NRF_SAADC_EVENT_RESULTDONE ? "NRF_SAADC_EVENT_RESULTDONE" : \
(event == NRF_SAADC_EVENT_CALIBRATEDONE ? "NRF_SAADC_EVENT_CALIBRATEDONE" : \
(event == NRF_SAADC_EVENT_STOPPED ? "NRF_SAADC_EVENT_STOPPED" : "UNKNOWN EVENT"))))))
#define EVT_TO_STR_LIMIT(event) (event == NRF_SAADC_LIMIT_LOW ? "NRF_SAADC_LIMIT_LOW" : \
(event == NRF_SAADC_LIMIT_HIGH ? "NRF_SAADC_LIMIT_HIGH" : "UNKNOWN EVENT"))
#else //SAADC_CONFIG_LOG_ENABLED
#define EVT_TO_STR(event) ""
#define NRF_LOG_LEVEL 0
#endif //SAADC_CONFIG_LOG_ENABLED
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
typedef enum
{
NRF_SAADC_STATE_IDLE = 0,
NRF_SAADC_STATE_BUSY = 1,
NRF_SAADC_STATE_CALIBRATION = 2
} nrf_saadc_state_t;
typedef struct
{
nrf_saadc_input_t pselp;
nrf_saadc_input_t pseln;
} nrf_saadc_psel_buffer;
static const nrf_drv_saadc_config_t m_default_config = NRF_DRV_SAADC_DEFAULT_CONFIG;
/** @brief SAADC control block.*/
typedef struct
{
nrf_drv_saadc_event_handler_t event_handler; ///< Event handler function pointer.
volatile nrf_saadc_value_t * p_buffer; ///< Sample buffer.
volatile uint16_t buffer_size; ///< Size of the sample buffer.
volatile nrf_saadc_value_t * p_secondary_buffer; ///< Secondary sample buffer.
uint32_t limits_enabled_flags; ///< Enabled limits flags.
uint16_t secondary_buffer_size; ///< Size of the secondary buffer.
uint16_t buffer_size_left; ///< When low power mode is active indicates how many samples left to convert on current buffer.
nrf_saadc_psel_buffer psel[NRF_SAADC_CHANNEL_COUNT]; ///< Pin configurations of SAADC channels.
nrf_drv_state_t state; ///< Driver initialization state.
nrf_saadc_state_t adc_state; ///< State of the SAADC.
uint8_t active_channels; ///< Number of enabled SAADC channels.
bool low_power_mode; ///< Indicates if low power mode is active.
bool conversions_end; ///< When low power mode is active indicates end of conversions on current buffer.
} nrf_drv_saadc_cb_t;
static nrf_drv_saadc_cb_t m_cb;
#define LOW_LIMIT_TO_FLAG(channel) ((2 * channel + 1))
#define HIGH_LIMIT_TO_FLAG(channel) ((2 * channel))
#define FLAG_IDX_TO_EVENT(idx) ((nrf_saadc_event_t)((uint32_t)NRF_SAADC_EVENT_CH0_LIMITH + \
4 * idx))
#define LIMIT_EVENT_TO_CHANNEL(event) (uint8_t)(((uint32_t)event - \
(uint32_t)NRF_SAADC_EVENT_CH0_LIMITH) / 8)
#define LIMIT_EVENT_TO_LIMIT_TYPE(event)((((uint32_t)event - (uint32_t)NRF_SAADC_EVENT_CH0_LIMITH) & 4) \
? NRF_SAADC_LIMIT_LOW : NRF_SAADC_LIMIT_HIGH)
#define HW_TIMEOUT 10000
void SAADC_IRQHandler(void)
{
if (nrf_saadc_event_check(NRF_SAADC_EVENT_END))
{
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SAADC_EVENT_END));
if (!m_cb.low_power_mode || m_cb.conversions_end)
{
nrf_drv_saadc_evt_t evt;
evt.type = NRF_DRV_SAADC_EVT_DONE;
evt.data.done.p_buffer = (nrf_saadc_value_t *)m_cb.p_buffer;
evt.data.done.size = m_cb.buffer_size;
if (m_cb.p_secondary_buffer == NULL)
{
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
}
else
{
m_cb.p_buffer = m_cb.p_secondary_buffer;
m_cb.buffer_size = m_cb.secondary_buffer_size;
m_cb.p_secondary_buffer = NULL;
if (!m_cb.low_power_mode)
{
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
}
}
m_cb.event_handler(&evt);
m_cb.conversions_end = false;
}
}
if (m_cb.low_power_mode && nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED))
{
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SAADC_EVENT_STARTED));
if (m_cb.buffer_size_left == 0)
{
// Sampling finished, next buffer in progress.
m_cb.buffer_size_left = m_cb.buffer_size - m_cb.active_channels;
nrf_saadc_buffer_init((nrf_saadc_value_t *)&m_cb.p_buffer[m_cb.buffer_size -
m_cb.buffer_size_left],
m_cb.active_channels);
}
else if (m_cb.buffer_size_left > m_cb.active_channels)
{
// More samples to convert than for single event.
m_cb.buffer_size_left -= m_cb.active_channels;
nrf_saadc_buffer_init((nrf_saadc_value_t *)&m_cb.p_buffer[m_cb.buffer_size -
m_cb.buffer_size_left],
m_cb.active_channels);
}
else if ((m_cb.buffer_size_left == m_cb.active_channels) &&
(m_cb.p_secondary_buffer != NULL))
{
// Samples to convert for one event, prepare next buffer.
m_cb.conversions_end = true;
m_cb.buffer_size_left = 0;
nrf_saadc_buffer_init((nrf_saadc_value_t *)m_cb.p_secondary_buffer,
m_cb.active_channels);
}
else if (m_cb.buffer_size_left == m_cb.active_channels)
{
// Samples to convert for one event, but no second buffer.
m_cb.conversions_end = true;
m_cb.buffer_size_left = 0;
}
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
}
if (nrf_saadc_event_check(NRF_SAADC_EVENT_CALIBRATEDONE))
{
nrf_saadc_event_clear(NRF_SAADC_EVENT_CALIBRATEDONE);
NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SAADC_EVENT_CALIBRATEDONE));
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
nrf_drv_saadc_evt_t evt;
evt.type = NRF_DRV_SAADC_EVT_CALIBRATEDONE;
m_cb.event_handler(&evt);
}
if (nrf_saadc_event_check(NRF_SAADC_EVENT_STOPPED))
{
nrf_saadc_event_clear(NRF_SAADC_EVENT_STOPPED);
NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SAADC_EVENT_STOPPED));
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
}
else
{
uint32_t limit_flags = m_cb.limits_enabled_flags;
uint32_t flag_idx;
nrf_saadc_event_t event;
while (limit_flags)
{
flag_idx = __CLZ(limit_flags);
limit_flags &= ~((1UL << 31) >> flag_idx);
event = FLAG_IDX_TO_EVENT(flag_idx);
if (nrf_saadc_event_check(event))
{
nrf_saadc_event_clear(event);
nrf_drv_saadc_evt_t evt;
evt.type = NRF_DRV_SAADC_EVT_LIMIT;
evt.data.limit.channel = LIMIT_EVENT_TO_CHANNEL(event);
evt.data.limit.limit_type = LIMIT_EVENT_TO_LIMIT_TYPE(event);
NRF_LOG_DEBUG("Event limit, channel: %d, limit type: %s.\r\n", evt.data.limit.channel, (uint32_t)EVT_TO_STR(evt.data.limit.limit_type));
m_cb.event_handler(&evt);
}
}
}
}
ret_code_t nrf_drv_saadc_init(nrf_drv_saadc_config_t const * p_config,
nrf_drv_saadc_event_handler_t event_handler)
{
ret_code_t err_code;
if (m_cb.state != NRF_DRV_STATE_UNINITIALIZED)
{
err_code = NRF_ERROR_INVALID_STATE;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n",
(uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (event_handler == NULL)
{
err_code = NRF_ERROR_INVALID_PARAM;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n",
(uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (p_config == NULL)
{
p_config = &m_default_config;
}
m_cb.event_handler = event_handler;
nrf_saadc_resolution_set(p_config->resolution);
nrf_saadc_oversample_set(p_config->oversample);
m_cb.low_power_mode = p_config->low_power_mode;
m_cb.state = NRF_DRV_STATE_INITIALIZED;
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
m_cb.active_channels = 0;
m_cb.limits_enabled_flags = 0;
m_cb.conversions_end = false;
nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
nrf_drv_common_irq_enable(SAADC_IRQn, p_config->interrupt_priority);
nrf_saadc_int_enable(NRF_SAADC_INT_END);
if (m_cb.low_power_mode)
{
nrf_saadc_int_enable(NRF_SAADC_INT_STARTED);
}
nrf_saadc_enable();
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
void nrf_drv_saadc_uninit(void)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
nrf_saadc_int_disable(NRF_SAADC_INT_ALL);
nrf_drv_common_irq_disable(SAADC_IRQn);
nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
// Wait for ADC being stopped.
uint32_t timeout = HW_TIMEOUT;
while (nrf_saadc_event_check(NRF_SAADC_EVENT_STOPPED) == 0 && timeout > 0)
{
--timeout;
}
ASSERT(timeout > 0);
nrf_saadc_disable();
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
for (uint8_t channel = 0; channel < NRF_SAADC_CHANNEL_COUNT; ++channel)
{
if (m_cb.psel[channel].pselp != NRF_SAADC_INPUT_DISABLED)
{
(void)nrf_drv_saadc_channel_uninit(channel);
}
}
m_cb.state = NRF_DRV_STATE_UNINITIALIZED;
}
ret_code_t nrf_drv_saadc_channel_init(uint8_t channel,
nrf_saadc_channel_config_t const * const p_config)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ASSERT(channel < NRF_SAADC_CHANNEL_COUNT);
// Oversampling can be used only with one channel.
ASSERT((nrf_saadc_oversample_get() == NRF_SAADC_OVERSAMPLE_DISABLED) ||
(m_cb.active_channels == 0));
ASSERT((p_config->pin_p <= NRF_SAADC_INPUT_VDD) &&
(p_config->pin_p > NRF_SAADC_INPUT_DISABLED));
ASSERT(p_config->pin_n <= NRF_SAADC_INPUT_VDD);
ret_code_t err_code;
// A channel can only be initialized if the driver is in the idle state.
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n",
(uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (!m_cb.psel[channel].pselp)
{
++m_cb.active_channels;
}
m_cb.psel[channel].pselp = p_config->pin_p;
m_cb.psel[channel].pseln = p_config->pin_n;
nrf_saadc_channel_init(channel, p_config);
nrf_saadc_channel_input_set(channel, p_config->pin_p, p_config->pin_n);
NRF_LOG_INFO("Channel initialized: %d.\r\n", channel);
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
ret_code_t nrf_drv_saadc_channel_uninit(uint8_t channel)
{
ASSERT(channel < NRF_SAADC_CHANNEL_COUNT)
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ret_code_t err_code;
// A channel can only be uninitialized if the driver is in the idle state.
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n",
(uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (m_cb.psel[channel].pselp)
{
--m_cb.active_channels;
}
m_cb.psel[channel].pselp = NRF_SAADC_INPUT_DISABLED;
m_cb.psel[channel].pseln = NRF_SAADC_INPUT_DISABLED;
nrf_saadc_channel_input_set(channel, NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
nrf_drv_saadc_limits_set(channel, NRF_DRV_SAADC_LIMITL_DISABLED, NRF_DRV_SAADC_LIMITH_DISABLED);
NRF_LOG_INFO("Channel denitialized: %d.\r\n", channel);
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n",
(uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
uint32_t nrf_drv_saadc_sample_task_get(void)
{
return nrf_saadc_task_address_get(
m_cb.low_power_mode ? NRF_SAADC_TASK_START : NRF_SAADC_TASK_SAMPLE);
}
ret_code_t nrf_drv_saadc_sample_convert(uint8_t channel, nrf_saadc_value_t * p_value)
{
ret_code_t err_code;
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
nrf_saadc_int_disable(NRF_SAADC_INT_STARTED | NRF_SAADC_INT_END);
nrf_saadc_buffer_init(p_value, 1);
if (m_cb.active_channels > 1)
{
for (uint8_t i = 0; i < NRF_SAADC_CHANNEL_COUNT; ++i)
{
nrf_saadc_channel_input_set(i, NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
}
}
nrf_saadc_channel_input_set(channel,
m_cb.psel[channel].pselp, m_cb.psel[channel].pseln);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
uint32_t timeout = HW_TIMEOUT;
while (0 == nrf_saadc_event_check(NRF_SAADC_EVENT_END) && timeout > 0)
{
timeout--;
}
nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
NRF_LOG_INFO("Conversion value: %d, channel.\r\n", *p_value, channel);
if (m_cb.active_channels > 1)
{
for (uint8_t i = 0; i < NRF_SAADC_CHANNEL_COUNT; ++i)
{
nrf_saadc_channel_input_set(i, m_cb.psel[i].pselp, m_cb.psel[i].pseln);
}
}
if (m_cb.low_power_mode)
{
nrf_saadc_int_enable(NRF_SAADC_INT_STARTED | NRF_SAADC_INT_END);
}
else
{
nrf_saadc_int_enable(NRF_SAADC_INT_END);
}
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
err_code = NRF_SUCCESS;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
ret_code_t nrf_drv_saadc_buffer_convert(nrf_saadc_value_t * p_buffer, uint16_t size)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ASSERT((size % m_cb.active_channels) == 0);
ret_code_t err_code;
nrf_saadc_int_disable(NRF_SAADC_INT_END | NRF_SAADC_INT_CALIBRATEDONE);
if (m_cb.adc_state == NRF_SAADC_STATE_CALIBRATION)
{
nrf_saadc_int_enable(NRF_SAADC_INT_END | NRF_SAADC_INT_CALIBRATEDONE);
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (m_cb.adc_state == NRF_SAADC_STATE_BUSY)
{
if ( m_cb.p_secondary_buffer)
{
nrf_saadc_int_enable(NRF_SAADC_INT_END);
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
else
{
m_cb.p_secondary_buffer = p_buffer;
m_cb.secondary_buffer_size = size;
if (!m_cb.low_power_mode)
{
while (nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED) == 0);
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_buffer_init(p_buffer, size);
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
err_code = NRF_SUCCESS;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
}
nrf_saadc_int_enable(NRF_SAADC_INT_END);
m_cb.adc_state = NRF_SAADC_STATE_BUSY;
m_cb.p_buffer = p_buffer;
m_cb.buffer_size = size;
m_cb.p_secondary_buffer = NULL;
NRF_LOG_INFO("Function: %d, buffer length: %d, active channels: %d.\r\n",
(uint32_t)__func__, size, m_cb.active_channels);
if (m_cb.low_power_mode)
{
m_cb.buffer_size_left = size;
nrf_saadc_buffer_init(p_buffer, m_cb.active_channels);
}
else
{
nrf_saadc_buffer_init(p_buffer, size);
nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
}
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
ret_code_t nrf_drv_saadc_sample()
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ret_code_t err_code = NRF_SUCCESS;
if (m_cb.adc_state != NRF_SAADC_STATE_BUSY)
{
err_code = NRF_ERROR_INVALID_STATE;
}
else if (m_cb.low_power_mode)
{
nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
}
else
{
nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
}
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
ret_code_t nrf_drv_saadc_calibrate_offset()
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ret_code_t err_code;
if (m_cb.adc_state != NRF_SAADC_STATE_IDLE)
{
err_code = NRF_ERROR_BUSY;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
m_cb.adc_state = NRF_SAADC_STATE_CALIBRATION;
nrf_saadc_event_clear(NRF_SAADC_EVENT_CALIBRATEDONE);
nrf_saadc_int_enable(NRF_SAADC_EVENT_CALIBRATEDONE);
nrf_saadc_task_trigger(NRF_SAADC_TASK_CALIBRATEOFFSET);
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
bool nrf_drv_saadc_is_busy(void)
{
return (m_cb.adc_state != NRF_SAADC_STATE_IDLE);
}
void nrf_drv_saadc_abort(void)
{
if (nrf_drv_saadc_is_busy())
{
nrf_saadc_event_clear(NRF_SAADC_EVENT_STOPPED);
nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
if (m_cb.adc_state == NRF_SAADC_STATE_CALIBRATION)
{
m_cb.adc_state = NRF_SAADC_STATE_IDLE;
}
else
{
// Wait for ADC being stopped.
uint32_t timeout = HW_TIMEOUT;
while ((m_cb.adc_state != NRF_SAADC_STATE_IDLE) && (timeout > 0))
{
--timeout;
}
ASSERT(timeout > 0);
}
m_cb.p_buffer = 0;
m_cb.p_secondary_buffer = 0;
NRF_LOG_INFO("Conversion aborted.\r\n");
}
}
void nrf_drv_saadc_limits_set(uint8_t channel, int16_t limit_low, int16_t limit_high)
{
ASSERT(m_cb.state != NRF_DRV_STATE_UNINITIALIZED);
ASSERT(m_cb.event_handler); // only non blocking mode supported
ASSERT(limit_low >= NRF_DRV_SAADC_LIMITL_DISABLED);
ASSERT(limit_high <= NRF_DRV_SAADC_LIMITH_DISABLED);
ASSERT(limit_low < limit_high);
nrf_saadc_channel_limits_set(channel, limit_low, limit_high);
uint32_t int_mask = nrf_saadc_limit_int_get(channel, NRF_SAADC_LIMIT_LOW);
if (limit_low == NRF_DRV_SAADC_LIMITL_DISABLED)
{
m_cb.limits_enabled_flags &= ~(0x80000000 >> LOW_LIMIT_TO_FLAG(channel));
nrf_saadc_int_disable(int_mask);
}
else
{
m_cb.limits_enabled_flags |= (0x80000000 >> LOW_LIMIT_TO_FLAG(channel));
nrf_saadc_int_enable(int_mask);
}
int_mask = nrf_saadc_limit_int_get(channel, NRF_SAADC_LIMIT_HIGH);
if (limit_high == NRF_DRV_SAADC_LIMITH_DISABLED)
{
m_cb.limits_enabled_flags &= ~(0x80000000 >> HIGH_LIMIT_TO_FLAG(channel));
nrf_saadc_int_disable(int_mask);
}
else
{
m_cb.limits_enabled_flags |= (0x80000000 >> HIGH_LIMIT_TO_FLAG(channel));
nrf_saadc_int_enable(int_mask);
}
}
#endif //NRF_MODULE_ENABLED(SAADC)
|
139648.c | #include "../../undead.h"
inherit INH+"forest_one.c";
void create()
{
::create();
set_exits(([
"north" :PATH+"room35",
"east" :PATH+"room48",
"southeast" :PATH+"room59",
"south" :PATH+"room58",
"southwest" :PATH+"room57"
]));
}
|
636143.c | /* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "keypad.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart3;
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART3_UART_Init(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
uint8_t key;
uint8_t prev_key;
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART3_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
key = KeypadGetKey();
if((key != KEYPAD_NO_PRESSED) && (prev_key == KEYPAD_NO_PRESSED)) {
HAL_UART_Transmit(&huart3, &key, 1, 10);
}
prev_key = key;
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 4;
RCC_OscInitStruct.PLL.PLLN = 168;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
static void MX_USART3_UART_Init(void)
{
/* USER CODE BEGIN USART3_Init 0 */
/* USER CODE END USART3_Init 0 */
/* USER CODE BEGIN USART3_Init 1 */
/* USER CODE END USART3_Init 1 */
huart3.Instance = USART3;
huart3.Init.BaudRate = 115200;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 2 */
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOE, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14, GPIO_PIN_RESET);
/*Configure GPIO pins : PE8 PE9 PE10 PE11 */
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : PE12 PE13 PE14 */
GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
699901.c | /*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.0 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* [email protected]
*/
/*! \file phy_procedures_lte_eNB.c
* \brief Implementation of eNB procedures from 36.213 LTE specifications
* \author R. Knopp, F. Kaltenberger, N. Nikaein, X. Foukas
* \date 2011
* \version 0.1
* \company Eurecom
* \email: [email protected],[email protected],[email protected], [email protected]
* \note
* \warning
*/
#include "PHY/defs.h"
#include "PHY/extern.h"
#include "SCHED/defs.h"
#include "SCHED/extern.h"
#include "PHY/LTE_TRANSPORT/if4_tools.h"
#include "PHY/LTE_TRANSPORT/if5_tools.h"
#ifdef EMOS
#include "SCHED/phy_procedures_emos.h"
#endif
//#define DEBUG_PHY_PROC (Already defined in cmake)
//#define DEBUG_ULSCH
#include "LAYER2/MAC/extern.h"
#include "LAYER2/MAC/defs.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
#include "T.h"
#include "assertions.h"
#include "msc.h"
#include <time.h>
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
#endif
#if defined(FLEXRAN_AGENT_SB_IF)
//Agent-related headers
#include "ENB_APP/flexran_agent_extern.h"
#include "ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.h"
#include "LAYER2/MAC/flexran_agent_mac_proto.h"
#endif
//#define DIAG_PHY
#define NS_PER_SLOT 500000
#define PUCCH 1
void exit_fun(const char* s);
extern int exit_openair;
struct timespec start_fh, start_fh_prev;
int start_fh_sf, start_fh_prev_sf;
// Fix per CC openair rf/if device update
// extern openair0_device openair0;
unsigned char dlsch_input_buffer[2700] __attribute__ ((aligned(32)));
int eNB_sync_buffer0[640*6] __attribute__ ((aligned(32)));
int eNB_sync_buffer1[640*6] __attribute__ ((aligned(32)));
int *eNB_sync_buffer[2] = {eNB_sync_buffer0, eNB_sync_buffer1};
extern uint16_t hundred_times_log10_NPRB[100];
unsigned int max_peak_val;
int max_sync_pos;
int harq_pid_updated[NUMBER_OF_UE_MAX][8] = {{0}};
int harq_pid_round[NUMBER_OF_UE_MAX][8] = {{0}};
//DCI_ALLOC_t dci_alloc[8];
#ifdef EMOS
fifo_dump_emos_eNB emos_dump_eNB;
#endif
#if defined(SMBV)
extern const char smbv_fname[];
extern unsigned short config_frames[4];
extern uint8_t smbv_frame_cnt;
#endif
#ifdef DIAG_PHY
extern int rx_sig_fifo;
#endif
uint8_t is_SR_subframe(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,uint8_t UE_id)
{
const int subframe = proc->subframe_rx;
const int frame = proc->frame_rx;
LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d Checking for SR TXOp(sr_ConfigIndex %d)\n",
eNB->Mod_id,eNB->ulsch[UE_id]->rnti,frame,subframe,
eNB->scheduling_request_config[UE_id].sr_ConfigIndex);
if (eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 4) { // 5 ms SR period
if ((subframe%5) == eNB->scheduling_request_config[UE_id].sr_ConfigIndex)
return(1);
} else if (eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 14) { // 10 ms SR period
if (subframe==(eNB->scheduling_request_config[UE_id].sr_ConfigIndex-5))
return(1);
} else if (eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 34) { // 20 ms SR period
if ((10*(frame&1)+subframe) == (eNB->scheduling_request_config[UE_id].sr_ConfigIndex-15))
return(1);
} else if (eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 74) { // 40 ms SR period
if ((10*(frame&3)+subframe) == (eNB->scheduling_request_config[UE_id].sr_ConfigIndex-35))
return(1);
} else if (eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 154) { // 80 ms SR period
if ((10*(frame&7)+subframe) == (eNB->scheduling_request_config[UE_id].sr_ConfigIndex-75))
return(1);
}
return(0);
}
int32_t add_ue(int16_t rnti, PHY_VARS_eNB *eNB)
{
uint8_t i;
LOG_D(PHY,"[eNB %d/%d] Adding UE with rnti %x\n",
eNB->Mod_id,
eNB->CC_id,
(uint16_t)rnti);
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if ((eNB->dlsch[i]==NULL) || (eNB->ulsch[i]==NULL)) {
MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed add ue %"PRIx16" (ENOMEM)", rnti);
LOG_E(PHY,"Can't add UE, not enough memory allocated\n");
return(-1);
} else {
if (eNB->UE_stats[i].crnti==0) {
MSC_LOG_EVENT(MSC_PHY_ENB, "0 Add ue %"PRIx16" ", rnti);
LOG_D(PHY,"UE_id %d associated with rnti %x\n",i, (uint16_t)rnti);
eNB->dlsch[i][0]->rnti = rnti;
eNB->ulsch[i]->rnti = rnti;
eNB->UE_stats[i].crnti = rnti;
eNB->UE_stats[i].Po_PUCCH1_below = 0;
eNB->UE_stats[i].Po_PUCCH1_above = (int32_t)pow(10.0,.1*(eNB->frame_parms.ul_power_control_config_common.p0_NominalPUCCH+eNB->rx_total_gain_dB));
eNB->UE_stats[i].Po_PUCCH = (int32_t)pow(10.0,.1*(eNB->frame_parms.ul_power_control_config_common.p0_NominalPUCCH+eNB->rx_total_gain_dB));
LOG_D(PHY,"Initializing Po_PUCCH: p0_NominalPUCCH %d, gain %d => %d\n",
eNB->frame_parms.ul_power_control_config_common.p0_NominalPUCCH,
eNB->rx_total_gain_dB,
eNB->UE_stats[i].Po_PUCCH);
return(i);
}
}
}
return(-1);
}
int mac_phy_remove_ue(module_id_t Mod_idP,rnti_t rntiP) {
uint8_t i;
int CC_id;
PHY_VARS_eNB *eNB;
for (CC_id=0;CC_id<MAX_NUM_CCs;CC_id++) {
eNB = PHY_vars_eNB_g[Mod_idP][CC_id];
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if ((eNB->dlsch[i]==NULL) || (eNB->ulsch[i]==NULL)) {
MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed remove ue %"PRIx16" (ENOMEM)", rntiP);
LOG_E(PHY,"Can't remove UE, not enough memory allocated\n");
return(-1);
} else {
if (eNB->UE_stats[i].crnti==rntiP) {
MSC_LOG_EVENT(MSC_PHY_ENB, "0 Removed ue %"PRIx16" ", rntiP);
LOG_D(PHY,"eNB %d removing UE %d with rnti %x\n",eNB->Mod_id,i,rntiP);
//LOG_D(PHY,("[PHY] UE_id %d\n",i);
clean_eNb_dlsch(eNB->dlsch[i][0]);
clean_eNb_ulsch(eNB->ulsch[i]);
//eNB->UE_stats[i].crnti = 0;
memset(&eNB->UE_stats[i],0,sizeof(LTE_eNB_UE_stats));
// mac_exit_wrapper("Removing UE");
return(i);
}
}
}
}
MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed remove ue %"PRIx16" (not found)", rntiP);
return(-1);
}
int8_t find_next_ue_index(PHY_VARS_eNB *eNB)
{
uint8_t i;
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if (eNB->UE_stats[i].crnti==0) {
/*if ((eNB->dlsch[i]) &&
(eNB->dlsch[i][0]) &&
(eNB->dlsch[i][0]->rnti==0))*/
LOG_D(PHY,"Next free UE id is %d\n",i);
return(i);
}
}
return(-1);
}
int get_ue_active_harq_pid(const uint8_t Mod_id,const uint8_t CC_id,const uint16_t rnti, const int frame, const uint8_t subframe,uint8_t *harq_pid,uint8_t *round,const uint8_t harq_flag)
{
LTE_eNB_DLSCH_t *DLSCH_ptr;
LTE_eNB_ULSCH_t *ULSCH_ptr;
uint8_t ulsch_subframe,ulsch_frame;
int i;
int8_t UE_id = find_ue(rnti,PHY_vars_eNB_g[Mod_id][CC_id]);
if (UE_id==-1) {
LOG_D(PHY,"Cannot find UE with rnti %x (Mod_id %d, CC_id %d)\n",rnti, Mod_id, CC_id);
*round=0;
return(-1);
}
if ((harq_flag == openair_harq_DL) || (harq_flag == openair_harq_RA)) {// this is a DL request
DLSCH_ptr = PHY_vars_eNB_g[Mod_id][CC_id]->dlsch[(uint32_t)UE_id][0];
if (harq_flag == openair_harq_RA) {
if (DLSCH_ptr->harq_processes[0] != NULL) {
*harq_pid = 0;
*round = DLSCH_ptr->harq_processes[0]->round;
return 0;
} else {
return -1;
}
}
/* let's go synchronous for the moment - maybe we can change at some point */
i = (frame * 10 + subframe) % 8;
if (DLSCH_ptr->harq_processes[i]->status == ACTIVE) {
*harq_pid = i;
*round = DLSCH_ptr->harq_processes[i]->round;
} else if (DLSCH_ptr->harq_processes[i]->status == SCH_IDLE) {
*harq_pid = i;
*round = 0;
} else {
printf("%s:%d: bad state for harq process - PLEASE REPORT!!\n", __FILE__, __LINE__);
abort();
}
} else { // This is a UL request
ULSCH_ptr = PHY_vars_eNB_g[Mod_id][CC_id]->ulsch[(uint32_t)UE_id];
ulsch_subframe = pdcch_alloc2ul_subframe(&PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms,subframe);
ulsch_frame = pdcch_alloc2ul_frame(&PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms,frame,subframe);
// Note this is for TDD configuration 3,4,5 only
*harq_pid = subframe2harq_pid(&PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms,
ulsch_frame,
ulsch_subframe);
*round = ULSCH_ptr->harq_processes[*harq_pid]->round;
LOG_T(PHY,"[eNB %d][PUSCH %d] Frame %d subframe %d Checking HARQ, round %d\n",Mod_id,*harq_pid,frame,subframe,*round);
}
return(0);
}
int16_t get_target_pusch_rx_power(const module_id_t module_idP, const uint8_t CC_id)
{
return PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.ul_power_control_config_common.p0_NominalPUSCH;
}
int16_t get_target_pucch_rx_power(const module_id_t module_idP, const uint8_t CC_id)
{
return PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.ul_power_control_config_common.p0_NominalPUCCH;
}
#ifdef EMOS
void phy_procedures_emos_eNB_TX(unsigned char subframe, PHY_VARS_eNB *eNB)
{
}
#endif
void phy_procedures_eNB_S_RX(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,relaying_type_t r_type)
{
UNUSED(r_type);
int subframe = proc->subframe_rx;
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d] Frame %d: Doing phy_procedures_eNB_S_RX(%d)\n", eNB->Mod_id,proc->frame_rx, subframe);
#endif
if (eNB->abstraction_flag == 0) {
lte_eNB_I0_measurements(eNB,
subframe,
0,
eNB->first_run_I0_measurements);
}
#ifdef PHY_ABSTRACTION
else {
lte_eNB_I0_measurements_emul(eNB,
0);
}
#endif
}
#ifdef EMOS
void phy_procedures_emos_eNB_RX(unsigned char subframe,PHY_VARS_eNB *eNB)
{
uint8_t aa;
uint16_t last_subframe_emos;
uint16_t pilot_pos1 = 3 - eNB->frame_parms.Ncp, pilot_pos2 = 10 - 2*eNB->frame_parms.Ncp;
uint32_t bytes;
last_subframe_emos=0;
#ifdef EMOS_CHANNEL
//if (last_slot%2==1) // this is for all UL subframes
if (subframe==3)
for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
memcpy(&emos_dump_eNB.channel[aa][last_subframe_emos*2*eNB->frame_parms.N_RB_UL*12],
&eNB->pusch_vars[0]->drs_ch_estimates[0][aa][eNB->frame_parms.N_RB_UL*12*pilot_pos1],
eNB->frame_parms.N_RB_UL*12*sizeof(int));
memcpy(&emos_dump_eNB.channel[aa][(last_subframe_emos*2+1)*eNB->frame_parms.N_RB_UL*12],
&eNB->pusch_vars[0]->drs_ch_estimates[0][aa][eNB->frame_parms.N_RB_UL*12*pilot_pos2],
eNB->frame_parms.N_RB_UL*12*sizeof(int));
}
#endif
if (subframe==4) {
emos_dump_eNB.timestamp = rt_get_time_ns();
emos_dump_eNB.frame_tx = eNB->proc[subframe].frame_rx;
emos_dump_eNB.rx_total_gain_dB = eNB->rx_total_gain_dB;
emos_dump_eNB.mimo_mode = eNB->transmission_mode[0];
memcpy(&emos_dump_eNB.measurements,
&eNB->measurements[0],
sizeof(PHY_MEASUREMENTS_eNB));
memcpy(&emos_dump_eNB.UE_stats[0],&eNB->UE_stats[0],NUMBER_OF_UE_MAX*sizeof(LTE_eNB_UE_stats));
bytes = rtf_put(CHANSOUNDER_FIFO_MINOR, &emos_dump_eNB, sizeof(fifo_dump_emos_eNB));
//bytes = rtf_put(CHANSOUNDER_FIFO_MINOR, "test", sizeof("test"));
if (bytes!=sizeof(fifo_dump_emos_eNB)) {
LOG_W(PHY,"[eNB %d] Frame %d, subframe %d, Problem writing EMOS data to FIFO (bytes=%d, size=%d)\n",
eNB->Mod_id,eNB->proc[(subframe+1)%10].frame_rx, subframe,bytes,sizeof(fifo_dump_emos_eNB));
} else {
if (eNB->proc[(subframe+1)%10].frame_tx%100==0) {
LOG_I(PHY,"[eNB %d] Frame %d (%d), subframe %d, Writing %d bytes EMOS data to FIFO\n",
eNB->Mod_id,eNB->proc[(subframe+1)%10].frame_rx, ((fifo_dump_emos_eNB*)&emos_dump_eNB)->frame_tx, subframe, bytes);
}
}
}
}
#endif
#define AMP_OVER_SQRT2 ((AMP*ONE_OVER_SQRT2_Q15)>>15)
#define AMP_OVER_2 (AMP>>1)
int QPSK[4]= {AMP_OVER_SQRT2|(AMP_OVER_SQRT2<<16),AMP_OVER_SQRT2|((65536-AMP_OVER_SQRT2)<<16),((65536-AMP_OVER_SQRT2)<<16)|AMP_OVER_SQRT2,((65536-AMP_OVER_SQRT2)<<16)|(65536-AMP_OVER_SQRT2)};
int QPSK2[4]= {AMP_OVER_2|(AMP_OVER_2<<16),AMP_OVER_2|((65536-AMP_OVER_2)<<16),((65536-AMP_OVER_2)<<16)|AMP_OVER_2,((65536-AMP_OVER_2)<<16)|(65536-AMP_OVER_2)};
unsigned int taus(void);
DCI_PDU DCI_pdu_tmp;
void pmch_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,PHY_VARS_RN *rn,relaying_type_t r_type) {
#if defined(Rel10) || defined(Rel14)
MCH_PDU *mch_pduP;
MCH_PDU mch_pdu;
// uint8_t sync_area=255;
#endif
int subframe = proc->subframe_tx;
if (eNB->abstraction_flag==0) {
// This is DL-Cell spec pilots in Control region
generate_pilots_slot(eNB,
eNB->common_vars.txdataF[0],
AMP,
subframe<<1,1);
}
#if defined(Rel10) || defined(Rel14)
// if mcch is active, send regardless of the node type: eNB or RN
// when mcch is active, MAC sched does not allow MCCH and MTCH multiplexing
mch_pduP = mac_xface->get_mch_sdu(eNB->Mod_id,
eNB->CC_id,
proc->frame_tx,
subframe);
switch (r_type) {
case no_relay:
if ((mch_pduP->Pdu_size > 0) && (mch_pduP->sync_area == 0)) // TEST: only transmit mcch for sync area 0
LOG_I(PHY,"[eNB%"PRIu8"] Frame %d subframe %d : Got MCH pdu for MBSFN (MCS %"PRIu8", TBS %d) \n",
eNB->Mod_id,proc->frame_tx,subframe,mch_pduP->mcs,
eNB->dlsch_MCH->harq_processes[0]->TBS>>3);
else {
LOG_D(PHY,"[DeNB %"PRIu8"] Frame %d subframe %d : Do not transmit MCH pdu for MBSFN sync area %"PRIu8" (%s)\n",
eNB->Mod_id,proc->frame_tx,subframe,mch_pduP->sync_area,
(mch_pduP->Pdu_size == 0)? "Empty MCH PDU":"Let RN transmit for the moment");
mch_pduP = NULL;
}
break;
case multicast_relay:
if ((mch_pduP->Pdu_size > 0) && ((mch_pduP->mcch_active == 1) || mch_pduP->msi_active==1)) {
LOG_I(PHY,"[RN %"PRIu8"] Frame %d subframe %d: Got the MCH PDU for MBSFN sync area %"PRIu8" (MCS %"PRIu8", TBS %"PRIu16")\n",
rn->Mod_id,rn->frame, subframe,
mch_pduP->sync_area,mch_pduP->mcs,mch_pduP->Pdu_size);
} else if (rn->mch_avtive[subframe%5] == 1) { // SF2 -> SF7, SF3 -> SF8
mch_pduP= &mch_pdu;
memcpy(&mch_pduP->payload, // could be a simple copy
rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->b,
rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->TBS>>3);
mch_pduP->Pdu_size = (uint16_t) (rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->TBS>>3);
mch_pduP->mcs = rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->mcs;
LOG_I(PHY,"[RN %"PRIu8"] Frame %d subframe %d: Forward the MCH PDU for MBSFN received on SF %d sync area %"PRIu8" (MCS %"PRIu8", TBS %"PRIu16")\n",
rn->Mod_id,rn->frame, subframe,subframe%5,
rn->sync_area[subframe%5],mch_pduP->mcs,mch_pduP->Pdu_size);
} else {
mch_pduP=NULL;
}
rn->mch_avtive[subframe]=0;
break;
default:
LOG_W(PHY,"[eNB %"PRIu8"] Frame %d subframe %d: unknown relaying type %d \n",
eNB->Mod_id,proc->frame_tx,subframe,r_type);
mch_pduP=NULL;
break;
}// switch
if (mch_pduP) {
fill_eNB_dlsch_MCH(eNB,mch_pduP->mcs,1,0);
// Generate PMCH
generate_mch(eNB,proc,(uint8_t*)mch_pduP->payload);
} else {
LOG_D(PHY,"[eNB/RN] Frame %d subframe %d: MCH not generated \n",proc->frame_tx,subframe);
}
#endif
}
void common_signal_procedures (PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc) {
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
int **txdataF = eNB->common_vars.txdataF[0];
uint8_t *pbch_pdu=&eNB->pbch_pdu[0];
int subframe = proc->subframe_tx;
int frame = proc->frame_tx;
// generate Cell-Specific Reference Signals for both slots
if (eNB->abstraction_flag==0) {
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,1);
generate_pilots_slot(eNB,
txdataF,
AMP,
subframe<<1,0);
// check that 2nd slot is for DL
if (subframe_select(fp,subframe) == SF_DL)
generate_pilots_slot(eNB,
txdataF,
AMP,
(subframe<<1)+1,0);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,0);
}
// First half of PSS/SSS (FDD, slot 0)
if (subframe == 0) {
if ((fp->frame_type == FDD) &&
(eNB->abstraction_flag==0)) {
generate_pss(txdataF,
AMP,
fp,
(fp->Ncp==NORMAL) ? 6 : 5,
0);
generate_sss(txdataF,
AMP,
fp,
(fp->Ncp==NORMAL) ? 5 : 4,
0);
}
// generate PBCH (Physical Broadcast CHannel) info
if ((frame&3) == 0) {
pbch_pdu[2] = 0;
// FIXME setting pbch_pdu[2] to zero makes the switch statement easier: remove all the or-operators
switch (fp->N_RB_DL) {
case 6:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (0<<5);
break;
case 15:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (1<<5);
break;
case 25:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (2<<5);
break;
case 50:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (3<<5);
break;
case 75:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (4<<5);
break;
case 100:
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (5<<5);
break;
default:
// FIXME if we get here, this should be flagged as an error, right?
pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (2<<5);
break;
}
pbch_pdu[2] = (pbch_pdu[2]&0xef) |
((fp->phich_config_common.phich_duration << 4)&0x10);
switch (fp->phich_config_common.phich_resource) {
case oneSixth:
pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (0<<2);
break;
case half:
pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (1<<2);
break;
case one:
pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (2<<2);
break;
case two:
pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (3<<2);
break;
default:
// unreachable
break;
}
pbch_pdu[2] = (pbch_pdu[2]&0xfc) | ((frame>>8)&0x3);
pbch_pdu[1] = frame&0xfc;
pbch_pdu[0] = 0;
}
/// First half of SSS (TDD, slot 1)
if ((fp->frame_type == TDD)&&
(eNB->abstraction_flag==0)){
generate_sss(txdataF,
AMP,
fp,
(fp->Ncp==NORMAL) ? 6 : 5,
1);
}
/// generate PBCH
if (eNB->abstraction_flag==0) {
generate_pbch(&eNB->pbch,
txdataF,
AMP,
fp,
pbch_pdu,
frame&3);
}
#ifdef PHY_ABSTRACTION
else {
generate_pbch_emul(eNB,pbch_pdu);
}
#endif
}
else if ((subframe == 1) &&
(fp->frame_type == TDD)&&
(eNB->abstraction_flag==0)) {
generate_pss(txdataF,
AMP,
fp,
2,
2);
}
// Second half of PSS/SSS (FDD, slot 10)
else if ((subframe == 5) &&
(fp->frame_type == FDD) &&
(eNB->abstraction_flag==0)) {
generate_pss(txdataF,
AMP,
&eNB->frame_parms,
(fp->Ncp==NORMAL) ? 6 : 5,
10);
generate_sss(txdataF,
AMP,
&eNB->frame_parms,
(fp->Ncp==NORMAL) ? 5 : 4,
10);
}
// Second-half of SSS (TDD, slot 11)
else if ((subframe == 5) &&
(fp->frame_type == TDD) &&
(eNB->abstraction_flag==0)) {
generate_sss(txdataF,
AMP,
fp,
(fp->Ncp==NORMAL) ? 6 : 5,
11);
}
// Second half of PSS (TDD, slot 12)
else if ((subframe == 6) &&
(fp->frame_type == TDD) &&
(eNB->abstraction_flag==0)) {
generate_pss(txdataF,
AMP,
fp,
2,
12);
}
}
void generate_eNB_dlsch_params(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci_alloc,const int UE_id) {
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
int frame = proc->frame_tx;
int subframe = proc->subframe_tx;
// if we have SI_RNTI, configure dlsch parameters and CCE index
if (dci_alloc->rnti == SI_RNTI) {
LOG_D(PHY,"Generating dlsch params for SI_RNTI\n");
generate_eNB_dlsch_params_from_dci(frame,
subframe,
&dci_alloc->dci_pdu[0],
dci_alloc->rnti,
dci_alloc->format,
&eNB->dlsch_SI,
fp,
NULL,
SI_RNTI,
0,
P_RNTI,
eNB->UE_stats[0].DL_pmi_single,
0);
eNB->dlsch_SI->nCCE[subframe] = dci_alloc->firstCCE;
LOG_T(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for common DCI (SI) => %"PRIu8"\n",eNB->Mod_id,frame,subframe,
eNB->dlsch_SI->nCCE[subframe]);
#if defined(SMBV)
// configure SI DCI
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, SI in SF %d DCI %"PRIu32"\n",frame,subframe,i);
smbv_configure_common_dci(smbv_fname,(smbv_frame_cnt*10) + (subframe), "SI", dci_alloc, i);
}
#endif
} else if (dci_alloc->ra_flag == 1) { // This is format 1A allocation for RA
// configure dlsch parameters and CCE index
LOG_D(PHY,"Generating dlsch params for RA_RNTI\n");
generate_eNB_dlsch_params_from_dci(frame,
subframe,
&dci_alloc->dci_pdu[0],
dci_alloc->rnti,
dci_alloc->format,
&eNB->dlsch_ra,
fp,
NULL,
SI_RNTI,
dci_alloc->rnti,
P_RNTI,
eNB->UE_stats[0].DL_pmi_single,
0);
eNB->dlsch_ra->nCCE[subframe] = dci_alloc->firstCCE;
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for common DCI (RA) => %"PRIu8"\n",eNB->Mod_id,frame,subframe,
eNB->dlsch_ra->nCCE[subframe]);
#if defined(SMBV)
// configure RA DCI
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, RA in SF %d DCI %"PRIu32"\n",frame,subframe,i);
smbv_configure_common_dci(smbv_fname,(smbv_frame_cnt*10) + (subframe), "RA", dci_alloc, i);
}
#endif
}
else if ((dci_alloc->format != format0)&&
(dci_alloc->format != format3)&&
(dci_alloc->format != format3A)&&
(dci_alloc->format != format4)){ // this is a normal DLSCH allocation
if (UE_id>=0) {
#if defined(SMBV)
// Configure this user
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, SF %d (SMBV SF %d) Configuring user %d with RNTI %"PRIu16" in TM%"PRIu8"\n",frame,subframe,(smbv_frame_cnt*10) + (subframe),UE_id+1,
dci_alloc->rnti,eNB->transmission_mode[(uint8_t)UE_id]);
smbv_configure_user(smbv_fname,UE_id+1,eNB->transmission_mode[(uint8_t)UE_id],dci_alloc->rnti);
}
#endif
LOG_D(PHY,"Generating dlsch params for RNTI %x\n",dci_alloc->rnti);
generate_eNB_dlsch_params_from_dci(frame,
subframe,
&dci_alloc->dci_pdu[0],
dci_alloc->rnti,
dci_alloc->format,
eNB->dlsch[(uint8_t)UE_id],
fp,
&eNB->pdsch_config_dedicated[UE_id],
SI_RNTI,
0,
P_RNTI,
eNB->UE_stats[(uint8_t)UE_id].DL_pmi_single,
eNB->transmission_mode[(uint8_t)UE_id]<7?0:eNB->transmission_mode[(uint8_t)UE_id]);
LOG_D(PHY,"[eNB %"PRIu8"][PDSCH %"PRIx16"/%"PRIu8"] Frame %d subframe %d: Generated dlsch params\n",
eNB->Mod_id,dci_alloc->rnti,eNB->dlsch[(uint8_t)UE_id][0]->current_harq_pid,frame,subframe);
T(T_ENB_PHY_DLSCH_UE_DCI, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(UE_id),
T_INT(dci_alloc->rnti), T_INT(dci_alloc->format),
T_INT(eNB->dlsch[(int)UE_id][0]->current_harq_pid),
T_INT(eNB->dlsch[(int)UE_id][0]->harq_processes[eNB->dlsch[(int)UE_id][0]->current_harq_pid]->mcs),
T_INT(eNB->dlsch[(int)UE_id][0]->harq_processes[eNB->dlsch[(int)UE_id][0]->current_harq_pid]->TBS));
eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe] = dci_alloc->firstCCE;
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for ue DCI (PDSCH %"PRIx16") => %"PRIu8"\n",eNB->Mod_id,frame,subframe,
dci_alloc->rnti,eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe]);
#if defined(SMBV)
// configure UE-spec DCI
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, PDSCH in SF %d DCI %"PRIu32"\n",frame,subframe,i);
smbv_configure_ue_spec_dci(smbv_fname,(smbv_frame_cnt*10) + (subframe), UE_id+1,dci_alloc, i);
}
#endif
LOG_D(PHY,"[eNB %"PRIu8"][DCI][PDSCH %"PRIx16"] Frame %d subframe %d UE_id %"PRId8" Generated DCI format %d, aggregation %d\n",
eNB->Mod_id, dci_alloc->rnti,
frame, subframe,UE_id,
dci_alloc->format,
1<<dci_alloc->L);
} else {
LOG_D(PHY,"[eNB %"PRIu8"][PDSCH] Frame %d : No UE_id with corresponding rnti %"PRIx16", dropping DLSCH\n",
eNB->Mod_id,frame,dci_alloc->rnti);
}
}
}
void generate_eNB_ulsch_params(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci_alloc,const int UE_id) {
int harq_pid;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
int frame = proc->frame_tx;
int subframe = proc->subframe_tx;
/*
uint16_t srsPeriodicity=0;
uint16_t srsOffset=0;
uint16_t srsConfigIndex=0;
uint16_t do_srs=0;
*/
uint16_t is_srs_pos=0;
LOG_D(PHY,
"[eNB %"PRIu8"][PUSCH %"PRIu8"] Frame %d subframe %d UL Frame %"PRIu32", UL Subframe %"PRIu8", Generated ULSCH (format0) DCI (rnti %"PRIx16", dci %"PRIx8"), aggregation %d\n",
eNB->Mod_id,
subframe2harq_pid(fp,
pdcch_alloc2ul_frame(fp,frame,subframe),
pdcch_alloc2ul_subframe(fp,subframe)),
frame,
subframe,
pdcch_alloc2ul_frame(fp,frame,subframe),
pdcch_alloc2ul_subframe(fp,subframe),
dci_alloc->rnti,
dci_alloc->dci_pdu[0],
1<<dci_alloc->L);
is_srs_pos = is_srs_occasion_common(fp,pdcch_alloc2ul_frame(fp,frame,subframe),pdcch_alloc2ul_subframe(fp,subframe));
/*
if (is_srs_pos && eNB->soundingrs_ul_config_dedicated[UE_id].srsConfigDedicatedSetup) {
srsConfigIndex = eNB->soundingrs_ul_config_dedicated[UE_id].srs_ConfigIndex;
compute_srs_pos(fp->frame_type, srsConfigIndex, &srsPeriodicity, &srsOffset);
if ((((10*pdcch_alloc2ul_frame(fp,frame,subframe)+pdcch_alloc2ul_subframe(fp,subframe)) % srsPeriodicity) == srsOffset)) {
do_srs = 1;
}
}
LOG_D(PHY,"frame %d (%d), subframe %d (%d), UE_id %d: is_srs_pos %d, do_SRS %d, index %d, period %d, offset %d \n",
frame,pdcch_alloc2ul_frame(fp,frame,subframe),subframe,pdcch_alloc2ul_subframe(fp,subframe),
UE_id,is_srs_pos,do_srs,srsConfigIndex,srsPeriodicity,srsOffset);
*/
generate_eNB_ulsch_params_from_dci(eNB,
proc,
&dci_alloc->dci_pdu[0],
dci_alloc->rnti,
format0,
UE_id,
SI_RNTI,
0,
P_RNTI,
CBA_RNTI,
is_srs_pos);
LOG_T(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resources for UE spec DCI (PUSCH %"PRIx16") => %d\n",
eNB->Mod_id,frame,subframe,dci_alloc->rnti,
dci_alloc->firstCCE);
#if defined(SMBV)
// configure UE-spec DCI for UL Grant
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, SF %d UL DCI %"PRIu32"\n",frame,subframe,i);
smbv_configure_ue_spec_dci(smbv_fname,(smbv_frame_cnt*10) + (subframe), UE_id+1, &DCI_pdu->dci_alloc[i], i);
}
#endif
// get the hard_pid for this subframe
harq_pid = subframe2harq_pid(fp,
pdcch_alloc2ul_frame(fp,frame,subframe),
pdcch_alloc2ul_subframe(fp,subframe));
if (harq_pid==255) { // should not happen, log an error and exit, this is a fatal error
LOG_E(PHY,"[eNB %"PRIu8"] Frame %d: Bad harq_pid for ULSCH allocation\n",eNB->Mod_id,frame);
mac_xface->macphy_exit("FATAL\n");
}
if ((dci_alloc->rnti >= CBA_RNTI) && (dci_alloc->rnti < P_RNTI))
eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->subframe_cba_scheduling_flag = 1;
else
eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
T(T_ENB_PHY_ULSCH_UE_DCI, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(UE_id),
T_INT(dci_alloc->rnti), T_INT(harq_pid),
T_INT(eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->mcs),
T_INT(eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->round),
T_INT(eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->first_rb),
T_INT(eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->nb_rb),
T_INT(eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->TBS),
T_INT(dci_alloc->L),
T_INT(dci_alloc->firstCCE));
}
void pdsch_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,LTE_eNB_DLSCH_t *dlsch, LTE_eNB_DLSCH_t *dlsch1,LTE_eNB_UE_stats *ue_stats,int ra_flag,int num_pdcch_symbols) {
int frame=proc->frame_tx;
int subframe=proc->subframe_tx;
int harq_pid = dlsch->current_harq_pid;
LTE_DL_eNB_HARQ_t *dlsch_harq=dlsch->harq_processes[harq_pid];
int input_buffer_length = dlsch_harq->TBS/8;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
uint8_t *DLSCH_pdu=NULL;
uint8_t DLSCH_pdu_tmp[input_buffer_length+4]; //[768*8];
uint8_t DLSCH_pdu_rar[256];
int i;
LOG_D(PHY,
"[eNB %"PRIu8"][PDSCH %"PRIx16"/%"PRIu8"] Frame %d, subframe %d: Generating PDSCH/DLSCH with input size = %"PRIu16", G %d, nb_rb %"PRIu16", mcs %"PRIu8", pmi_alloc %"PRIx64", rv %"PRIu8" (round %"PRIu8")\n",
eNB->Mod_id, dlsch->rnti,harq_pid,
frame, subframe, input_buffer_length,
get_G(fp,
dlsch_harq->nb_rb,
dlsch_harq->rb_alloc,
get_Qm(dlsch_harq->mcs),
dlsch_harq->Nl,
num_pdcch_symbols,
frame,
subframe,
dlsch_harq->mimo_mode==TM7?7:0),
dlsch_harq->nb_rb,
dlsch_harq->mcs,
pmi2hex_2Ar1(dlsch_harq->pmi_alloc),
dlsch_harq->rvidx,
dlsch_harq->round);
#if defined(MESSAGE_CHART_GENERATOR_PHY)
MSC_LOG_TX_MESSAGE(
MSC_PHY_ENB,MSC_PHY_UE,
NULL,0,
"%05u:%02u PDSCH/DLSCH input size = %"PRIu16", G %d, nb_rb %"PRIu16", mcs %"PRIu8", pmi_alloc %"PRIx16", rv %"PRIu8" (round %"PRIu8")",
frame, subframe,
input_buffer_length,
get_G(fp,
dlsch_harq->nb_rb,
dlsch_harq->rb_alloc,
get_Qm(dlsch_harq->mcs),
dlsch_harq->Nl,
num_pdcch_symbols,
frame,
subframe,
dlsch_harq->mimo_mode==TM7?7:0),
dlsch_harq->nb_rb,
dlsch_harq->mcs,
pmi2hex_2Ar1(dlsch_harq->pmi_alloc),
dlsch_harq->rvidx,
dlsch_harq->round);
#endif
if (ue_stats) ue_stats->dlsch_sliding_cnt++;
if (dlsch_harq->round == 0) {
if (ue_stats)
ue_stats->dlsch_trials[harq_pid][0]++;
if (eNB->mac_enabled==1) {
if (ra_flag == 0) {
DLSCH_pdu = mac_xface->get_dlsch_sdu(eNB->Mod_id,
eNB->CC_id,
frame,
dlsch->rnti,
0);
}
else {
int16_t crnti = mac_xface->fill_rar(eNB->Mod_id,
eNB->CC_id,
frame,
DLSCH_pdu_rar,
fp->N_RB_UL,
input_buffer_length);
DLSCH_pdu = DLSCH_pdu_rar;
int UE_id;
if (crnti!=0)
UE_id = add_ue(crnti,eNB);
else
UE_id = -1;
if (UE_id==-1) {
LOG_W(PHY,"[eNB] Max user count reached.\n");
mac_xface->cancel_ra_proc(eNB->Mod_id,
eNB->CC_id,
frame,
crnti);
} else {
eNB->UE_stats[(uint32_t)UE_id].mode = RA_RESPONSE;
// Initialize indicator for first SR (to be cleared after ConnectionSetup is acknowledged)
eNB->first_sr[(uint32_t)UE_id] = 1;
generate_eNB_ulsch_params_from_rar(DLSCH_pdu,
frame,
subframe,
eNB->ulsch[(uint32_t)UE_id],
fp);
LOG_D(PHY,"[eNB][RAPROC] Frame %d subframe %d, Activated Msg3 demodulation for UE %"PRId8" in frame %"PRIu32", subframe %"PRIu8"\n",
frame,
subframe,
UE_id,
eNB->ulsch[(uint32_t)UE_id]->Msg3_frame,
eNB->ulsch[(uint32_t)UE_id]->Msg3_subframe);
/* TODO: get rid of this hack. The problem is that the eNodeB may
* sometimes wrongly generate PHICH because somewhere 'phich_active' was
* not reset to 0, due to an unidentified reason. When adding this
* resetting here the problem seems to disappear completely.
*/
LOG_D(PHY, "hack: set phich_active to 0 for UE %d fsf %d %d all HARQs\n", UE_id, frame, subframe);
for (i = 0; i < 8; i++)
eNB->ulsch[(uint32_t)UE_id]->harq_processes[i]->phich_active = 0;
mac_xface->set_msg3_subframe(eNB->Mod_id, eNB->CC_id, frame, subframe, (uint16_t)crnti,
eNB->ulsch[UE_id]->Msg3_frame, eNB->ulsch[UE_id]->Msg3_subframe);
T(T_ENB_PHY_MSG3_ALLOCATION, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe),
T_INT(UE_id), T_INT((uint16_t)crnti), T_INT(1 /* 1 is for initial transmission*/),
T_INT(eNB->ulsch[UE_id]->Msg3_frame), T_INT(eNB->ulsch[UE_id]->Msg3_subframe));
}
if (ue_stats) ue_stats->total_TBS_MAC += dlsch_harq->TBS;
}
}
else {
DLSCH_pdu = DLSCH_pdu_tmp;
for (i=0; i<input_buffer_length; i++)
DLSCH_pdu[i] = (unsigned char)(taus()&0xff);
}
#if defined(SMBV)
// Configures the data source of allocation (allocation is configured by DCI)
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, Configuring PDSCH payload in SF %d alloc %"PRIu8"\n",frame,(smbv_frame_cnt*10) + (subframe),smbv_alloc_cnt);
// smbv_configure_datalist_for_user(smbv_fname, find_ue(dlsch->rnti,eNB)+1, DLSCH_pdu, input_buffer_length);
}
#endif
#ifdef DEBUG_PHY_PROC
#ifdef DEBUG_DLSCH
LOG_T(PHY,"eNB DLSCH SDU: \n");
//eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe] = DCI_pdu->dci_alloc[i].firstCCE;
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for ue DCI (PDSCH %"PRIx16") => %"PRIu8"/%u\n",eNB->Mod_id,eNB->proc[sched_subframe].frame_tx,subframe,
DCI_pdu->dci_alloc[i].rnti,eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe],DCI_pdu->dci_alloc[i].firstCCE);
for (i=0; i<dlsch_harq->TBS>>3; i++)
LOG_T(PHY,"%"PRIx8".",DLSCH_pdu[i]);
LOG_T(PHY,"\n");
#endif
#endif
} else {
ue_stats->dlsch_trials[harq_pid][dlsch_harq->round]++;
#ifdef DEBUG_PHY_PROC
#ifdef DEBUG_DLSCH
LOG_D(PHY,"[eNB] This DLSCH is a retransmission\n");
#endif
#endif
}
if (eNB->abstraction_flag==0) {
LOG_D(PHY,"Generating DLSCH/PDSCH %d\n",ra_flag);
// 36-212
start_meas(&eNB->dlsch_encoding_stats);
eNB->te(eNB,
DLSCH_pdu,
num_pdcch_symbols,
dlsch,
frame,subframe,
&eNB->dlsch_rate_matching_stats,
&eNB->dlsch_turbo_encoding_stats,
&eNB->dlsch_interleaving_stats);
stop_meas(&eNB->dlsch_encoding_stats);
// 36-211
start_meas(&eNB->dlsch_scrambling_stats);
dlsch_scrambling(fp,
0,
dlsch,
get_G(fp,
dlsch_harq->nb_rb,
dlsch_harq->rb_alloc,
get_Qm(dlsch_harq->mcs),
dlsch_harq->Nl,
num_pdcch_symbols,
frame,subframe,
0),
0,
subframe<<1);
stop_meas(&eNB->dlsch_scrambling_stats);
start_meas(&eNB->dlsch_modulation_stats);
dlsch_modulation(eNB,
eNB->common_vars.txdataF[0],
AMP,
subframe,
num_pdcch_symbols,
dlsch,
dlsch1);
stop_meas(&eNB->dlsch_modulation_stats);
}
#ifdef PHY_ABSTRACTION
else {
start_meas(&eNB->dlsch_encoding_stats);
dlsch_encoding_emul(eNB,
DLSCH_pdu,
dlsch);
stop_meas(&eNB->dlsch_encoding_stats);
}
#endif
dlsch->active = 0;
}
void phy_procedures_eNB_TX(PHY_VARS_eNB *eNB,
eNB_rxtx_proc_t *proc,
relaying_type_t r_type,
PHY_VARS_RN *rn,
int do_meas,
int do_pdcch_flag)
{
UNUSED(rn);
int frame=proc->frame_tx;
int subframe=proc->subframe_tx;
// uint16_t input_buffer_length;
uint32_t i,j,aa;
uint8_t harq_pid;
DCI_PDU *DCI_pdu;
DCI_PDU DCI_pdu_tmp;
int8_t UE_id=0;
uint8_t num_pdcch_symbols=0;
uint8_t ul_subframe;
uint32_t ul_frame;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
DCI_ALLOC_t *dci_alloc=(DCI_ALLOC_t *)NULL;
int offset = eNB->CC_id;//proc == &eNB->proc.proc_rxtx[0] ? 0 : 1;
#if defined(SMBV)
// counts number of allocations in subframe
// there is at least one allocation for PDCCH
uint8_t smbv_alloc_cnt = 1;Exiting eNB thread RXn_TXnp4
#endif
if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)==SF_UL)) return;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX+offset,1);
if (do_meas==1) start_meas(&eNB->phy_proc_tx);
T(T_ENB_PHY_DL_TICK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe));
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
// If we've dropped the UE, go back to PRACH mode for this UE
if ((frame==0)&&(subframe==0)) {
if (eNB->UE_stats[i].crnti > 0) {
LOG_I(PHY,"UE %d : rnti %x\n",i,eNB->UE_stats[i].crnti);
}
}
if (eNB->UE_stats[i].ulsch_consecutive_errors == ULSCH_max_consecutive_errors) {
LOG_W(PHY,"[eNB %d, CC %d] frame %d, subframe %d, UE %d: ULSCH consecutive error count reached %u, triggering UL Failure\n",
eNB->Mod_id,eNB->CC_id,frame,subframe, i, eNB->UE_stats[i].ulsch_consecutive_errors);
eNB->UE_stats[i].ulsch_consecutive_errors=0;
mac_xface->UL_failure_indication(eNB->Mod_id,
eNB->CC_id,
frame,
eNB->UE_stats[i].crnti,
subframe);
}
}
// Get scheduling info for next subframe
// This is called only for the CC_id = 0 and triggers scheduling for all CC_id's
if (eNB->mac_enabled==1) {
if (eNB->CC_id == 0) {
mac_xface->eNB_dlsch_ulsch_scheduler(eNB->Mod_id,0,frame,subframe);//,1);
}
}
// clear the transmit data array for the current subframe
if (eNB->abstraction_flag==0) {
for (aa=0; aa<fp->nb_antenna_ports_eNB; aa++) {
memset(&eNB->common_vars.txdataF[0][aa][subframe*fp->ofdm_symbol_size*(fp->symbols_per_tti)],
0,fp->ofdm_symbol_size*(fp->symbols_per_tti)*sizeof(int32_t));
}
}
if (is_pmch_subframe(frame,subframe,fp)) {
pmch_procedures(eNB,proc,rn,r_type);
}
else {
// this is not a pmch subframe, so generate PSS/SSS/PBCH
common_signal_procedures(eNB,proc);
}
#if defined(SMBV)
// PBCH takes one allocation
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
if (subframe==0)
smbv_alloc_cnt++;
}
#endif
if (eNB->mac_enabled==1) {
// Parse DCI received from MAC
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PDCCH_TX,1);
DCI_pdu = mac_xface->get_dci_sdu(eNB->Mod_id,
eNB->CC_id,
frame,
subframe);
}
else {
DCI_pdu = &DCI_pdu_tmp;
#ifdef EMOS_CHANNEL
fill_dci_emos(DCI_pdu,eNB);
#else
fill_dci(DCI_pdu,eNB,proc);
// clear previous allocation information for all UEs
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if (eNB->dlsch[i][0]){
for (j=0; j<8; j++)
eNB->dlsch[i][0]->harq_processes[j]->round = 0;
}
}
#endif
}
// clear existing ulsch dci allocations before applying info from MAC (this is table
ul_subframe = pdcch_alloc2ul_subframe(fp,subframe);
ul_frame = pdcch_alloc2ul_frame(fp,frame,subframe);
if ((subframe_select(fp,ul_subframe)==SF_UL) ||
(fp->frame_type == FDD)) {
harq_pid = subframe2harq_pid(fp,ul_frame,ul_subframe);
// clear DCI allocation maps for new subframe
for (i=0; i<NUMBER_OF_UE_MAX; i++)
if (eNB->ulsch[i]) {
eNB->ulsch[i]->harq_processes[harq_pid]->dci_alloc=0;
eNB->ulsch[i]->harq_processes[harq_pid]->rar_alloc=0;
}
}
// clear previous allocation information for all UEs
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if (eNB->dlsch[i][0])
eNB->dlsch[i][0]->subframe_tx[subframe] = 0;
}
/* save old HARQ information needed for PHICH generation */
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if (eNB->ulsch[i]) {
/* Store first_rb and n_DMRS for correct PHICH generation below.
* For PHICH generation we need "old" values of last scheduling
* for this HARQ process. 'generate_eNB_dlsch_params' below will
* overwrite first_rb and n_DMRS and 'generate_phich_top', done
* after 'generate_eNB_dlsch_params', would use the "new" values
* instead of the "old" ones.
*
* This has been tested for FDD only, may be wrong for TDD.
*
* TODO: maybe we should restructure the code to be sure it
* is done correctly. The main concern is if the code
* changes and first_rb and n_DMRS are modified before
* we reach here, then the PHICH processing will be wrong,
* using wrong first_rb and n_DMRS values to compute
* ngroup_PHICH and nseq_PHICH.
*
* TODO: check if that works with TDD.
*/
if ((subframe_select(fp,ul_subframe)==SF_UL) ||
(fp->frame_type == FDD)) {
harq_pid = subframe2harq_pid(fp,ul_frame,ul_subframe);
eNB->ulsch[i]->harq_processes[harq_pid]->previous_first_rb =
eNB->ulsch[i]->harq_processes[harq_pid]->first_rb;
eNB->ulsch[i]->harq_processes[harq_pid]->previous_n_DMRS =
eNB->ulsch[i]->harq_processes[harq_pid]->n_DMRS;
}
}
}
// loop over all DCIs for this subframe to generate DLSCH allocations
for (i=0; i<DCI_pdu->Num_common_dci + DCI_pdu->Num_ue_spec_dci ; i++) {
LOG_D(PHY,"[eNB] Subframe %d: DCI %d/%d : rnti %x, CCEind %d\n",subframe,i,DCI_pdu->Num_common_dci+DCI_pdu->Num_ue_spec_dci,DCI_pdu->dci_alloc[i].rnti,DCI_pdu->dci_alloc[i].firstCCE);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,DCI_pdu->dci_alloc[i].rnti);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,DCI_pdu->dci_alloc[i].format);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,DCI_pdu->dci_alloc[i].firstCCE);
dci_alloc = &DCI_pdu->dci_alloc[i];
if ((dci_alloc->rnti<= P_RNTI) &&
(dci_alloc->ra_flag!=1)) {
if (eNB->mac_enabled==1)
UE_id = find_ue((int16_t)dci_alloc->rnti,eNB);
else
UE_id = i;
}
else UE_id=0;
generate_eNB_dlsch_params(eNB,proc,dci_alloc,UE_id);
}
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,(frame*10)+subframe);
// Apply physicalConfigDedicated if needed
// This is for UEs that have received this IE, which changes these DL and UL configuration, we apply after a delay for the eNodeB UL parameters
phy_config_dedicated_eNB_step2(eNB);
// Now loop again over the DCIs for UL configuration
for (i=0; i<DCI_pdu->Num_common_dci + DCI_pdu->Num_ue_spec_dci ; i++) {
dci_alloc = &DCI_pdu->dci_alloc[i];
if (dci_alloc->format == format0) { // this is a ULSCH allocation
if (eNB->mac_enabled==1)
UE_id = find_ue((int16_t)dci_alloc->rnti,eNB);
else
UE_id = i;
if (UE_id<0) { // should not happen, log an error and exit, this is a fatal error
LOG_E(PHY,"[eNB %"PRIu8"] Frame %d: Unknown UE_id for rnti %"PRIx16"\n",eNB->Mod_id,frame,dci_alloc->rnti);
mac_xface->macphy_exit("FATAL\n");
}
generate_eNB_ulsch_params(eNB,proc,dci_alloc,UE_id);
}
}
// if we have DCI to generate do it now
if ((DCI_pdu->Num_common_dci + DCI_pdu->Num_ue_spec_dci)>0) {
} else { // for emulation!!
eNB->num_ue_spec_dci[(subframe)&1]=0;
eNB->num_common_dci[(subframe)&1]=0;
}
if (eNB->abstraction_flag == 0) {
if (do_pdcch_flag) {
if (DCI_pdu->Num_ue_spec_dci+DCI_pdu->Num_common_dci > 0) {
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d, subframe %d: Calling generate_dci_top (pdcch) (common %"PRIu8",ue_spec %"PRIu8")\n",eNB->Mod_id,frame, subframe,
DCI_pdu->Num_common_dci,DCI_pdu->Num_ue_spec_dci);
}
num_pdcch_symbols = generate_dci_top(DCI_pdu->Num_ue_spec_dci,
DCI_pdu->Num_common_dci,
DCI_pdu->dci_alloc,
0,
AMP,
fp,
eNB->common_vars.txdataF[0],
subframe);
}
else {
num_pdcch_symbols = DCI_pdu->num_pdcch_symbols;
LOG_D(PHY,"num_pdcch_symbols %"PRIu8" (dci common %"PRIu8", dci uespec %"PRIu8")\n",num_pdcch_symbols,
DCI_pdu->Num_common_dci,DCI_pdu->Num_ue_spec_dci);
}
}
#ifdef PHY_ABSTRACTION // FIXME this ifdef seems suspicious
else {
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d, subframe %d: Calling generate_dci_to_emul\n",eNB->Mod_id,frame, subframe);
num_pdcch_symbols = generate_dci_top_emul(eNB,DCI_pdu->Num_ue_spec_dci,DCI_pdu->Num_common_dci,DCI_pdu->dci_alloc,subframe);
}
#endif
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,DCI_pdu->num_pdcch_symbols);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PDCCH_TX,0);
#if defined(SMBV)
// Sets up PDCCH and DCI table
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4) && ((DCI_pdu->Num_common_dci+DCI_pdu->Num_ue_spec_dci)>0)) {
LOG_D(PHY,"[SMBV] Frame %3d, SF %d PDCCH, number of DCIs %d\n",frame,subframe,DCI_pdu->Num_common_dci+DCI_pdu->Num_ue_spec_dci);
dump_dci(fp,&DCI_pdu->dci_alloc[0]);
smbv_configure_pdcch(smbv_fname,(smbv_frame_cnt*10) + (subframe),num_pdcch_symbols,DCI_pdu->Num_common_dci+DCI_pdu->Num_ue_spec_dci);
}
#endif
// Check for SI activity
if ((eNB->dlsch_SI) && (eNB->dlsch_SI->active == 1)) {
pdsch_procedures(eNB,proc,eNB->dlsch_SI,(LTE_eNB_DLSCH_t*)NULL,(LTE_eNB_UE_stats*)NULL,0,num_pdcch_symbols);
#if defined(SMBV)
// Configures the data source of allocation (allocation is configured by DCI)
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, Configuring SI payload in SF %d alloc %"PRIu8"\n",frame,(smbv_frame_cnt*10) + (subframe),smbv_alloc_cnt);
smbv_configure_datalist_for_alloc(smbv_fname, smbv_alloc_cnt++, (smbv_frame_cnt*10) + (subframe), DLSCH_pdu, input_buffer_length);
}
#endif
}
// Check for RA activity
if ((eNB->dlsch_ra) && (eNB->dlsch_ra->active == 1)) {
#if defined(SMBV)
// Configures the data source of allocation (allocation is configured by DCI)
if (smbv_is_config_frame(frame) && (smbv_frame_cnt < 4)) {
LOG_D(PHY,"[SMBV] Frame %3d, Configuring RA payload in SF %d alloc %"PRIu8"\n",frame,(smbv_frame_cnt*10) + (subframe),smbv_alloc_cnt);
smbv_configure_datalist_for_alloc(smbv_fname, smbv_alloc_cnt++, (smbv_frame_cnt*10) + (subframe), dlsch_input_buffer, input_buffer_length);
}
#endif
LOG_D(PHY,"[eNB %"PRIu8"][RAPROC] Frame %d, subframe %d: Calling generate_dlsch (RA),Msg3 frame %"PRIu32", Msg3 subframe %"PRIu8"\n",
eNB->Mod_id,
frame, subframe,
eNB->ulsch[(uint32_t)UE_id]->Msg3_frame,
eNB->ulsch[(uint32_t)UE_id]->Msg3_subframe);
pdsch_procedures(eNB,proc,eNB->dlsch_ra,(LTE_eNB_DLSCH_t*)NULL,(LTE_eNB_UE_stats*)NULL,1,num_pdcch_symbols);
eNB->dlsch_ra->active = 0;
}
// Now scan UE specific DLSCH
for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++)
{
if ((eNB->dlsch[(uint8_t)UE_id][0])&&
(eNB->dlsch[(uint8_t)UE_id][0]->rnti>0)&&
(eNB->dlsch[(uint8_t)UE_id][0]->active == 1)) {
pdsch_procedures(eNB,proc,eNB->dlsch[(uint8_t)UE_id][0],eNB->dlsch[(uint8_t)UE_id][1],&eNB->UE_stats[(uint32_t)UE_id],0,num_pdcch_symbols);
}
else if ((eNB->dlsch[(uint8_t)UE_id][0])&&
(eNB->dlsch[(uint8_t)UE_id][0]->rnti>0)&&
(eNB->dlsch[(uint8_t)UE_id][0]->active == 0)) {
// clear subframe TX flag since UE is not scheduled for PDSCH in this subframe (so that we don't look for PUCCH later)
eNB->dlsch[(uint8_t)UE_id][0]->subframe_tx[subframe]=0;
}
}
// if we have PHICH to generate
if (is_phich_subframe(fp,subframe))
{
generate_phich_top(eNB,
proc,
AMP,
0);
}
/*
if (frame>=10 && subframe>=9) {
write_output("/tmp/txsigF0.m","txsF0", &eNB->common_vars.txdataF[0][0][0],120*eNB->frame_parms.ofdm_symbol_size,1,1);
write_output("/tmp/txsigF1.m","txsF1", &eNB->common_vars.txdataF[0][0][0],120*eNB->frame_parms.ofdm_symbol_size,1,1);
abort();
}
*/
#ifdef EMOS
phy_procedures_emos_eNB_TX(subframe, eNB);
#endif
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX+offset,0);
if (do_meas==1) stop_meas(&eNB->phy_proc_tx);
}
void process_Msg3(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,uint8_t UE_id, uint8_t harq_pid)
{
// this prepares the demodulation of the first PUSCH of a new user, containing Msg3
int subframe = proc->subframe_rx;
int frame = proc->frame_rx;
LOG_D(PHY,"[eNB %d][RAPROC] frame %d : subframe %d : process_Msg3 UE_id %d (active %d, subframe %d, frame %d)\n",
eNB->Mod_id,
frame,subframe,
UE_id,eNB->ulsch[(uint32_t)UE_id]->Msg3_active,
eNB->ulsch[(uint32_t)UE_id]->Msg3_subframe,
eNB->ulsch[(uint32_t)UE_id]->Msg3_frame);
eNB->ulsch[(uint32_t)UE_id]->Msg3_flag = 0;
if ((eNB->ulsch[(uint32_t)UE_id]->Msg3_active == 1) &&
(eNB->ulsch[(uint32_t)UE_id]->Msg3_subframe == subframe) &&
(eNB->ulsch[(uint32_t)UE_id]->Msg3_frame == (uint32_t)frame)) {
// harq_pid = 0;
eNB->ulsch[(uint32_t)UE_id]->Msg3_active = 0;
eNB->ulsch[(uint32_t)UE_id]->Msg3_flag = 1;
eNB->ulsch[(uint32_t)UE_id]->harq_processes[harq_pid]->subframe_scheduling_flag=1;
LOG_D(PHY,"[eNB %d][RAPROC] frame %d, subframe %d: Setting subframe_scheduling_flag (Msg3) for UE %d\n",
eNB->Mod_id,
frame,subframe,UE_id);
}
}
// This function retrieves the harq_pid of the corresponding DLSCH process
// and updates the error statistics of the DLSCH based on the received ACK
// info from UE along with the round index. It also performs the fine-grain
// rate-adaptation based on the error statistics derived from the ACK/NAK process
void process_HARQ_feedback(uint8_t UE_id,
PHY_VARS_eNB *eNB,
eNB_rxtx_proc_t *proc,
uint8_t pusch_flag,
uint8_t *pucch_payload,
uint8_t pucch_sel,
uint8_t SR_payload)
{
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
uint8_t dl_harq_pid[8],dlsch_ACK[8],dl_subframe;
LTE_eNB_DLSCH_t *dlsch = eNB->dlsch[(uint32_t)UE_id][0];
LTE_eNB_UE_stats *ue_stats = &eNB->UE_stats[(uint32_t)UE_id];
LTE_DL_eNB_HARQ_t *dlsch_harq_proc;
uint8_t subframe_m4,M,m;
int mp;
int all_ACKed=1,nb_alloc=0,nb_ACK=0;
int frame = proc->frame_rx;
int subframe = proc->subframe_rx;
int harq_pid = subframe2harq_pid( fp,frame,subframe);
if (fp->frame_type == FDD) { //FDD
subframe_m4 = (subframe<4) ? subframe+6 : subframe-4;
dl_harq_pid[0] = dlsch->harq_ids[subframe_m4];
M=1;
if (pusch_flag == 1) {
dlsch_ACK[0] = eNB->ulsch[(uint8_t)UE_id]->harq_processes[harq_pid]->o_ACK[0];
if (dlsch->subframe_tx[subframe_m4]==1)
LOG_D(PHY,"[eNB %d] Frame %d: Received ACK/NAK %d on PUSCH for subframe %d\n",eNB->Mod_id,
frame,dlsch_ACK[0],subframe_m4);
}
else {
dlsch_ACK[0] = pucch_payload[0];
LOG_D(PHY,"[eNB %d] Frame %d: Received ACK/NAK %d on PUCCH for subframe %d\n",eNB->Mod_id,
frame,dlsch_ACK[0],subframe_m4);
/*
if (dlsch_ACK[0]==0)
AssertFatal(0,"Exiting on NAK on PUCCH\n");
*/
}
#if defined(MESSAGE_CHART_GENERATOR_PHY)
MSC_LOG_RX_MESSAGE(
MSC_PHY_ENB,MSC_PHY_UE,
NULL,0,
"%05u:%02u %s received %s rnti %x harq id %u tx SF %u",
frame,subframe,
(pusch_flag == 1)?"PUSCH":"PUCCH",
(dlsch_ACK[0])?"ACK":"NACK",
dlsch->rnti,
dl_harq_pid[0],
subframe_m4
);
#endif
} else { // TDD Handle M=1,2 cases only
M=ul_ACK_subframe2_M(fp,
subframe);
// Now derive ACK information for TDD
if (pusch_flag == 1) { // Do PUSCH ACK/NAK first
// detect missing DAI
//FK: this code is just a guess
//RK: not exactly, yes if scheduled from PHICH (i.e. no DCI format 0)
// otherwise, it depends on how many of the PDSCH in the set are scheduled, we can leave it like this,
// but we have to adapt the code below. For example, if only one out of 2 are scheduled, only 1 bit o_ACK is used
dlsch_ACK[0] = eNB->ulsch[(uint8_t)UE_id]->harq_processes[harq_pid]->o_ACK[0];
dlsch_ACK[1] = (eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode == bundling)
?eNB->ulsch[(uint8_t)UE_id]->harq_processes[harq_pid]->o_ACK[0]:eNB->ulsch[(uint8_t)UE_id]->harq_processes[harq_pid]->o_ACK[1];
}
else { // PUCCH ACK/NAK
if ((SR_payload == 1)&&(pucch_sel!=2)) { // decode Table 7.3 if multiplexing and SR=1
nb_ACK = 0;
if (M == 2) {
if ((pucch_payload[0] == 1) && (pucch_payload[1] == 1)) // b[0],b[1]
nb_ACK = 1;
else if ((pucch_payload[0] == 1) && (pucch_payload[1] == 0))
nb_ACK = 2;
} else if (M == 3) {
if ((pucch_payload[0] == 1) && (pucch_payload[1] == 1))
nb_ACK = 1;
else if ((pucch_payload[0] == 1) && (pucch_payload[1] == 0))
nb_ACK = 2;
else if ((pucch_payload[0] == 0) && (pucch_payload[1] == 1))
nb_ACK = 3;
}
} else if (pucch_sel == 2) { // bundling or M=1
dlsch_ACK[0] = pucch_payload[0];
dlsch_ACK[1] = pucch_payload[0];
} else { // multiplexing with no SR, this is table 10.1
if (M==1)
dlsch_ACK[0] = pucch_payload[0];
else if (M==2) {
if (((pucch_sel == 1) && (pucch_payload[0] == 1) && (pucch_payload[1] == 1)) ||
((pucch_sel == 0) && (pucch_payload[0] == 0) && (pucch_payload[1] == 1)))
dlsch_ACK[0] = 1;
else
dlsch_ACK[0] = 0;
if (((pucch_sel == 1) && (pucch_payload[0] == 1) && (pucch_payload[1] == 1)) ||
((pucch_sel == 1) && (pucch_payload[0] == 0) && (pucch_payload[1] == 0)))
dlsch_ACK[1] = 1;
else
dlsch_ACK[1] = 0;
}
}
}
}
// handle case where positive SR was transmitted with multiplexing
if ((SR_payload == 1)&&(pucch_sel!=2)&&(pusch_flag == 0)) {
nb_alloc = 0;
for (m=0; m<M; m++) {
dl_subframe = ul_ACK_subframe2_dl_subframe(fp,
subframe,
m);
if (dlsch->subframe_tx[dl_subframe]==1)
nb_alloc++;
}
if (nb_alloc == nb_ACK)
all_ACKed = 1;
else
all_ACKed = 0;
}
for (m=0,mp=-1; m<M; m++) {
dl_subframe = ul_ACK_subframe2_dl_subframe(fp,
subframe,
m);
if (dlsch->subframe_tx[dl_subframe]==1) {
if (pusch_flag == 1)
mp++;
else
mp = m;
dl_harq_pid[m] = dlsch->harq_ids[dl_subframe];
harq_pid_updated[UE_id][dl_harq_pid[m]] = 1;
if ((pucch_sel != 2)&&(pusch_flag == 0)) { // multiplexing
if ((SR_payload == 1)&&(all_ACKed == 1))
dlsch_ACK[m] = 1;
else
dlsch_ACK[m] = 0;
}
if (dl_harq_pid[m]<dlsch->Mdlharq) {
dlsch_harq_proc = dlsch->harq_processes[dl_harq_pid[m]];
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x/%d] subframe %d, status %d, round %d (mcs %d, rv %d, TBS %d)\n",eNB->Mod_id,
dlsch->rnti,dl_harq_pid[m],dl_subframe,
dlsch_harq_proc->status,dlsch_harq_proc->round,
dlsch->harq_processes[dl_harq_pid[m]]->mcs,
dlsch->harq_processes[dl_harq_pid[m]]->rvidx,
dlsch->harq_processes[dl_harq_pid[m]]->TBS);
if (dlsch_harq_proc->status==DISABLED)
LOG_E(PHY,"dlsch_harq_proc is disabled? \n");
#endif
if ((dl_harq_pid[m]<dlsch->Mdlharq) &&
(dlsch_harq_proc->status == ACTIVE)) {
// dl_harq_pid of DLSCH is still active
if ( dlsch_ACK[mp]==0) {
// Received NAK
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x/%d] M = %d, m= %d, mp=%d NAK Received in round %d, requesting retransmission\n",eNB->Mod_id,
dlsch->rnti,dl_harq_pid[m],M,m,mp,dlsch_harq_proc->round);
#endif
T(T_ENB_PHY_DLSCH_UE_NACK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(UE_id), T_INT(dlsch->rnti),
T_INT(dl_harq_pid[m]));
if (dlsch_harq_proc->round == 0)
ue_stats->dlsch_NAK_round0++;
ue_stats->dlsch_NAK[dl_harq_pid[m]][dlsch_harq_proc->round]++;
// then Increment DLSCH round index
dlsch_harq_proc->round++;
if (dlsch_harq_proc->round == dlsch->Mlimit) {
// This was the last round for DLSCH so reset round and increment l2_error counter
#ifdef DEBUG_PHY_PROC
LOG_W(PHY,"[eNB %d][PDSCH %x/%d] DLSCH retransmissions exhausted, dropping packet\n",eNB->Mod_id,
dlsch->rnti,dl_harq_pid[m]);
#endif
#if defined(MESSAGE_CHART_GENERATOR_PHY)
MSC_LOG_EVENT(MSC_PHY_ENB, "0 HARQ DLSCH Failed RNTI %"PRIx16" round %u",
dlsch->rnti,
dlsch_harq_proc->round);
#endif
dlsch_harq_proc->round = 0;
ue_stats->dlsch_l2_errors[dl_harq_pid[m]]++;
dlsch_harq_proc->status = SCH_IDLE;
dlsch->harq_ids[dl_subframe] = dlsch->Mdlharq;
}
} else {
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x/%d] ACK Received in round %d, resetting process\n",eNB->Mod_id,
dlsch->rnti,dl_harq_pid[m],dlsch_harq_proc->round);
#endif
T(T_ENB_PHY_DLSCH_UE_ACK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(UE_id), T_INT(dlsch->rnti),
T_INT(dl_harq_pid[m]));
ue_stats->dlsch_ACK[dl_harq_pid[m]][dlsch_harq_proc->round]++;
// Received ACK so set round to 0 and set dlsch_harq_pid IDLE
dlsch_harq_proc->round = 0;
dlsch_harq_proc->status = SCH_IDLE;
dlsch->harq_ids[dl_subframe] = dlsch->Mdlharq;
ue_stats->total_TBS = ue_stats->total_TBS +
eNB->dlsch[(uint8_t)UE_id][0]->harq_processes[dl_harq_pid[m]]->TBS;
/*
ue_stats->total_transmitted_bits = ue_stats->total_transmitted_bits +
eNB->dlsch[(uint8_t)UE_id][0]->harq_processes[dl_harq_pid[m]]->TBS;
*/
}
// Do fine-grain rate-adaptation for DLSCH
if (ue_stats->dlsch_NAK_round0 > dlsch->error_threshold) {
if (ue_stats->dlsch_mcs_offset == 1)
ue_stats->dlsch_mcs_offset=0;
else
ue_stats->dlsch_mcs_offset=-1;
}
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[process_HARQ_feedback] Frame %d Setting round to %d for pid %d (subframe %d)\n",frame,
dlsch_harq_proc->round,dl_harq_pid[m],subframe);
#endif
harq_pid_round[UE_id][dl_harq_pid[m]] = dlsch_harq_proc->round;
// Clear NAK stats and adjust mcs offset
// after measurement window timer expires
if (ue_stats->dlsch_sliding_cnt == dlsch->ra_window_size) {
if ((ue_stats->dlsch_mcs_offset == 0) && (ue_stats->dlsch_NAK_round0 < 2))
ue_stats->dlsch_mcs_offset = 1;
if ((ue_stats->dlsch_mcs_offset == 1) && (ue_stats->dlsch_NAK_round0 > 2))
ue_stats->dlsch_mcs_offset = 0;
if ((ue_stats->dlsch_mcs_offset == 0) && (ue_stats->dlsch_NAK_round0 > 2))
ue_stats->dlsch_mcs_offset = -1;
if ((ue_stats->dlsch_mcs_offset == -1) && (ue_stats->dlsch_NAK_round0 < 2))
ue_stats->dlsch_mcs_offset = 0;
ue_stats->dlsch_NAK_round0 = 0;
ue_stats->dlsch_sliding_cnt = 0;
}
}
}
}
}
}
void get_n1_pucch_eNB(PHY_VARS_eNB *eNB,
eNB_rxtx_proc_t *proc,
uint8_t UE_id,
int16_t *n1_pucch0,
int16_t *n1_pucch1,
int16_t *n1_pucch2,
int16_t *n1_pucch3)
{
LTE_DL_FRAME_PARMS *frame_parms=&eNB->frame_parms;
uint8_t nCCE0,nCCE1;
int sf;
int frame = proc->frame_rx;
int subframe = proc->subframe_rx;
if (frame_parms->frame_type == FDD ) {
sf = (subframe<4) ? (subframe+6) : (subframe-4);
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[sf]>0) {
*n1_pucch0 = frame_parms->pucch_config_common.n1PUCCH_AN + eNB->dlsch[(uint32_t)UE_id][0]->nCCE[sf];
*n1_pucch1 = -1;
} else {
*n1_pucch0 = -1;
*n1_pucch1 = -1;
}
} else {
switch (frame_parms->tdd_config) {
case 1: // DL:S:UL:UL:DL:DL:S:UL:UL:DL
if (subframe == 2) { // ACK subframes 5 and 6
/* if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[6]>0) {
nCCE1 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[6];
*n1_pucch1 = get_Np(frame_parms->N_RB_DL,nCCE1,1) + nCCE1 + frame_parms->pucch_config_common.n1PUCCH_AN;
}
else
*n1_pucch1 = -1;*/
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[5]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[5];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0+ frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
*n1_pucch1 = -1;
} else if (subframe == 3) { // ACK subframe 9
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[9]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[9];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0 +frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
*n1_pucch1 = -1;
} else if (subframe == 7) { // ACK subframes 0 and 1
//harq_ack[0].nCCE;
//harq_ack[1].nCCE;
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[0]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[0];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0 + frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
*n1_pucch1 = -1;
} else if (subframe == 8) { // ACK subframes 4
//harq_ack[4].nCCE;
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[4]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[4];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0 + frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
*n1_pucch1 = -1;
} else {
LOG_D(PHY,"[eNB %d] frame %d: phy_procedures_lte.c: get_n1pucch, illegal subframe %d for tdd_config %d\n",
eNB->Mod_id,
frame,
subframe,frame_parms->tdd_config);
return;
}
break;
case 3: // DL:S:UL:UL:UL:DL:DL:DL:DL:DL
if (subframe == 2) { // ACK subframes 5,6 and 1 (S in frame-2), forget about n-11 for the moment (S-subframe)
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[6]>0) {
nCCE1 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[6];
*n1_pucch1 = get_Np(frame_parms->N_RB_DL,nCCE1,1) + nCCE1 + frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch1 = -1;
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[5]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[5];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0+ frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
} else if (subframe == 3) { // ACK subframes 7 and 8
LOG_D(PHY,"get_n1_pucch_eNB : subframe 3, subframe_tx[7] %d, subframe_tx[8] %d\n",
eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[7],eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[8]);
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[8]>0) {
nCCE1 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[8];
*n1_pucch1 = get_Np(frame_parms->N_RB_DL,nCCE1,1) + nCCE1 + frame_parms->pucch_config_common.n1PUCCH_AN;
LOG_D(PHY,"nCCE1 %d, n1_pucch1 %d\n",nCCE1,*n1_pucch1);
} else
*n1_pucch1 = -1;
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[7]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[7];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0 +frame_parms->pucch_config_common.n1PUCCH_AN;
LOG_D(PHY,"nCCE0 %d, n1_pucch0 %d\n",nCCE0,*n1_pucch0);
} else
*n1_pucch0 = -1;
} else if (subframe == 4) { // ACK subframes 9 and 0
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[0]>0) {
nCCE1 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[0];
*n1_pucch1 = get_Np(frame_parms->N_RB_DL,nCCE1,1) + nCCE1 + frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch1 = -1;
if (eNB->dlsch[(uint32_t)UE_id][0]->subframe_tx[9]>0) {
nCCE0 = eNB->dlsch[(uint32_t)UE_id][0]->nCCE[9];
*n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0 +frame_parms->pucch_config_common.n1PUCCH_AN;
} else
*n1_pucch0 = -1;
} else {
LOG_D(PHY,"[eNB %d] Frame %d: phy_procedures_lte.c: get_n1pucch, illegal subframe %d for tdd_config %d\n",
eNB->Mod_id,frame,subframe,frame_parms->tdd_config);
return;
}
break;
} // switch tdd_config
// Don't handle the case M>2
*n1_pucch2 = -1;
*n1_pucch3 = -1;
}
}
void prach_procedures(PHY_VARS_eNB *eNB) {
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
uint16_t preamble_energy_list[64],preamble_delay_list[64];
uint16_t preamble_max,preamble_energy_max;
uint16_t i;
int8_t UE_id;
int subframe = eNB->proc.subframe_prach;
int frame = eNB->proc.frame_prach;
uint8_t CC_id = eNB->CC_id;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PRACH_RX,1);
memset(&preamble_energy_list[0],0,64*sizeof(uint16_t));
memset(&preamble_delay_list[0],0,64*sizeof(uint16_t));
if (eNB->abstraction_flag == 0) {
LOG_D(PHY,"[eNB %d][RAPROC] Frame %d, Subframe %d : PRACH RX Signal Power : %d dBm\n",eNB->Mod_id,
frame,subframe,dB_fixed(signal_energy(&eNB->common_vars.rxdata[0][0][subframe*fp->samples_per_tti],512)) - eNB->rx_total_gain_dB);
rx_prach(eNB,
preamble_energy_list,
preamble_delay_list,
frame,
0);
} else {
for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
LOG_D(PHY,"[RAPROC] UE_id %d (%p), generate_prach %d, UE RSI %d, eNB RSI %d preamble index %d\n",
UE_id,PHY_vars_UE_g[UE_id][CC_id],PHY_vars_UE_g[UE_id][CC_id]->generate_prach,
PHY_vars_UE_g[UE_id][CC_id]->frame_parms.prach_config_common.rootSequenceIndex,
fp->prach_config_common.rootSequenceIndex,
PHY_vars_UE_g[UE_id][CC_id]->prach_PreambleIndex);
if ((PHY_vars_UE_g[UE_id][CC_id]->generate_prach==1) &&
(PHY_vars_UE_g[UE_id][CC_id]->frame_parms.prach_config_common.rootSequenceIndex ==
fp->prach_config_common.rootSequenceIndex) ) {
preamble_energy_list[PHY_vars_UE_g[UE_id][CC_id]->prach_PreambleIndex] = 800;
preamble_delay_list[PHY_vars_UE_g[UE_id][CC_id]->prach_PreambleIndex] = 5;
}
}
}
preamble_energy_max = preamble_energy_list[0];
preamble_max = 0;
for (i=1; i<64; i++) {
if (preamble_energy_max < preamble_energy_list[i]) {
preamble_energy_max = preamble_energy_list[i];
preamble_max = i;
}
}
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[RAPROC] Most likely preamble %d, energy %d dB delay %d\n",
preamble_max,
preamble_energy_list[preamble_max],
preamble_delay_list[preamble_max]);
#endif
if (preamble_energy_list[preamble_max] > 580) {
UE_id = find_next_ue_index(eNB);
if (UE_id>=0) {
eNB->UE_stats[(uint32_t)UE_id].UE_timing_offset = preamble_delay_list[preamble_max]&0x1FFF; //limit to 13 (=11+2) bits
eNB->UE_stats[(uint32_t)UE_id].sector = 0;
LOG_D(PHY,"[eNB %d/%d][RAPROC] Frame %d, subframe %d Initiating RA procedure (UE_id %d) with preamble %d, energy %d.%d dB, delay %d\n",
eNB->Mod_id,
eNB->CC_id,
frame,
subframe,
UE_id,
preamble_max,
preamble_energy_max/10,
preamble_energy_max%10,
preamble_delay_list[preamble_max]);
T(T_ENB_PHY_INITIATE_RA_PROCEDURE, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(UE_id),
T_INT(preamble_max), T_INT(preamble_energy_max), T_INT(preamble_delay_list[preamble_max]));
if (eNB->mac_enabled==1) {
uint8_t update_TA = 4;
uint8_t update_TA2 = 1;
switch (fp->N_RB_DL) {
case 6:
update_TA = 16;
break;
case 25:
update_TA = 4;
break;
case 50:
update_TA = 2;
break;
case 75:
update_TA = 3;
update_TA2 = 2;
case 100:
update_TA = 1;
break;
}
mac_xface->initiate_ra_proc(eNB->Mod_id,
eNB->CC_id,
frame,
preamble_max,
preamble_delay_list[preamble_max]*update_TA/update_TA2,
0,subframe,0);
}
} else {
MSC_LOG_EVENT(MSC_PHY_ENB, "0 RA Failed add user, too many");
LOG_I(PHY,"[eNB %d][RAPROC] frame %d, subframe %d: Unable to add user, max user count reached\n",
eNB->Mod_id,frame, subframe);
}
}
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PRACH_RX,0);
}
void pucch_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,int UE_id,int harq_pid,uint8_t do_srs)
{
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
uint8_t SR_payload = 0,*pucch_payload=NULL,pucch_payload0[2]= {0,0},pucch_payload1[2]= {0,0};
int16_t n1_pucch0 = -1, n1_pucch1 = -1, n1_pucch2 = -1, n1_pucch3 = -1;
uint8_t do_SR = 0;
uint8_t pucch_sel = 0;
int32_t metric0=0,metric1=0,metric0_SR=0;
ANFBmode_t bundling_flag;
PUCCH_FMT_t format;
const int subframe = proc->subframe_rx;
const int frame = proc->frame_rx;
if ((eNB->dlsch[UE_id][0]) &&
(eNB->dlsch[UE_id][0]->rnti>0) &&
(eNB->ulsch[UE_id]->harq_processes[harq_pid]->subframe_scheduling_flag==0)) {
// check SR availability
do_SR = is_SR_subframe(eNB,proc,UE_id);
// do_SR = 0;
// Now ACK/NAK
// First check subframe_tx flag for earlier subframes
get_n1_pucch_eNB(eNB,
proc,
UE_id,
&n1_pucch0,
&n1_pucch1,
&n1_pucch2,
&n1_pucch3);
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d, subframe %d Checking for PUCCH (%d,%d,%d,%d) SR %d\n",
eNB->Mod_id,eNB->dlsch[UE_id][0]->rnti,
frame,subframe,
n1_pucch0,n1_pucch1,n1_pucch2,n1_pucch3,do_SR);
if ((n1_pucch0==-1) && (n1_pucch1==-1) && (do_SR==0)) { // no TX PDSCH that have to be checked and no SR for this UE_id
} else {
// otherwise we have some PUCCH detection to do
// Null out PUCCH PRBs for noise measurement
switch(fp->N_RB_UL) {
case 6:
eNB->rb_mask_ul[0] |= (0x1 | (1<<5)); //position 5
break;
case 15:
eNB->rb_mask_ul[0] |= (0x1 | (1<<14)); // position 14
break;
case 25:
eNB->rb_mask_ul[0] |= (0x1 | (1<<24)); // position 24
break;
case 50:
eNB->rb_mask_ul[0] |= 0x1;
eNB->rb_mask_ul[1] |= (1<<17); // position 49 (49-32)
break;
case 75:
eNB->rb_mask_ul[0] |= 0x1;
eNB->rb_mask_ul[2] |= (1<<10); // position 74 (74-64)
break;
case 100:
eNB->rb_mask_ul[0] |= 0x1;
eNB->rb_mask_ul[3] |= (1<<3); // position 99 (99-96)
break;
default:
LOG_E(PHY,"Unknown number for N_RB_UL %d\n",fp->N_RB_UL);
break;
}
if (do_SR == 1) {
eNB->UE_stats[UE_id].sr_total++;
if (eNB->abstraction_flag == 0) {
metric0_SR = rx_pucch(eNB,
pucch_format1,
UE_id,
eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex,
0, // n2_pucch
do_srs, // shortened format
&SR_payload,
frame,
subframe,
PUCCH1_THRES);
LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d Checking SR is %d (SR n1pucch is %d)\n",
eNB->Mod_id,
eNB->ulsch[UE_id]->rnti,
frame,
subframe,
SR_payload,
eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex);
}
#ifdef PHY_ABSTRACTION
else {
metric0_SR = rx_pucch_emul(eNB,
proc,
UE_id,
pucch_format1,
0,
&SR_payload);
LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d Checking SR (UE SR %d/%d)\n",eNB->Mod_id,
eNB->ulsch[UE_id]->rnti,frame,subframe,SR_payload,eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex);
}
#endif
}// do_SR==1
if ((n1_pucch0==-1) && (n1_pucch1==-1)) { // just check for SR
} else if (fp->frame_type==FDD) { // FDD
// if SR was detected, use the n1_pucch from SR, else use n1_pucch0
// n1_pucch0 = (SR_payload==1) ? eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex:n1_pucch0;
LOG_D(PHY,"Demodulating PUCCH for ACK/NAK: n1_pucch0 %d (%d), SR_payload %d\n",n1_pucch0,eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex,SR_payload);
if (eNB->abstraction_flag == 0) {
metric0 = rx_pucch(eNB,
pucch_format1a,
UE_id,
(uint16_t)n1_pucch0,
0, //n2_pucch
do_srs, // shortened format
pucch_payload0,
frame,
subframe,
PUCCH1a_THRES);
}
#ifdef PHY_ABSTRACTION
else {
metric0 = rx_pucch_emul(eNB,
proc,
UE_id,
pucch_format1a,
0,
pucch_payload0);
}
#endif
/* cancel SR detection if reception on n1_pucch0 is better than on SR PUCCH resource index */
if (do_SR && metric0 > metric0_SR) SR_payload = 0;
if (do_SR && metric0 <= metric0_SR) {
/* when transmitting ACK/NACK on SR PUCCH resource index, SR payload is always 1 */
SR_payload = 1;
if (eNB->abstraction_flag == 0) {
metric0=rx_pucch(eNB,
pucch_format1a,
UE_id,
eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex,
0, //n2_pucch
do_srs, // shortened format
pucch_payload0,
frame,
subframe,
PUCCH1a_THRES);
}
#ifdef PHY_ABSTRACTION
else {
metric0 = rx_pucch_emul(eNB,
proc,
UE_id,
pucch_format1a,
0,
pucch_payload0);
}
#endif
}
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d subframe %d pucch1a (FDD) payload %d (metric %d)\n",
eNB->Mod_id,
eNB->dlsch[UE_id][0]->rnti,
frame,subframe,
pucch_payload0[0],metric0);
#endif
process_HARQ_feedback(UE_id,eNB,proc,
0,// pusch_flag
pucch_payload0,
2,
SR_payload);
} // FDD
else { //TDD
bundling_flag = eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode;
// fix later for 2 TB case and format1b
if ((fp->frame_type==FDD) ||
(bundling_flag==bundling) ||
((fp->frame_type==TDD)&&(fp->tdd_config==1)&&((subframe!=2)&&(subframe!=7)))) {
format = pucch_format1a;
} else {
format = pucch_format1b;
}
// if SR was detected, use the n1_pucch from SR
if (SR_payload==1) {
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d subframe %d Checking ACK/NAK (%d,%d,%d,%d) format %d with SR\n",eNB->Mod_id,
eNB->dlsch[UE_id][0]->rnti,
frame,subframe,
n1_pucch0,n1_pucch1,n1_pucch2,n1_pucch3,format);
#endif
if (eNB->abstraction_flag == 0)
metric0 = rx_pucch(eNB,
format,
UE_id,
eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex,
0, //n2_pucch
do_srs, // shortened format
pucch_payload0,
frame,
subframe,
PUCCH1a_THRES);
else {
#ifdef PHY_ABSTRACTION
metric0 = rx_pucch_emul(eNB,proc,
UE_id,
format,
0,
pucch_payload0);
#endif
}
} else { //using n1_pucch0/n1_pucch1 resources
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d subframe %d Checking ACK/NAK (%d,%d,%d,%d) format %d\n",eNB->Mod_id,
eNB->dlsch[UE_id][0]->rnti,
frame,subframe,
n1_pucch0,n1_pucch1,n1_pucch2,n1_pucch3,format);
#endif
metric0=0;
metric1=0;
// Check n1_pucch0 metric
if (n1_pucch0 != -1) {
if (eNB->abstraction_flag == 0)
metric0 = rx_pucch(eNB,
format,
UE_id,
(uint16_t)n1_pucch0,
0, // n2_pucch
do_srs, // shortened format
pucch_payload0,
frame,
subframe,
PUCCH1a_THRES);
else {
#ifdef PHY_ABSTRACTION
metric0 = rx_pucch_emul(eNB,
proc,
UE_id,
format,
0,
pucch_payload0);
#endif
}
}
// Check n1_pucch1 metric
if (n1_pucch1 != -1) {
if (eNB->abstraction_flag == 0)
metric1 = rx_pucch(eNB,
format,
UE_id,
(uint16_t)n1_pucch1,
0, //n2_pucch
do_srs, // shortened format
pucch_payload1,
frame,
subframe,
PUCCH1a_THRES);
else {
#ifdef PHY_ABSTRACTION
metric1 = rx_pucch_emul(eNB,
proc,
UE_id,
format,
1,
pucch_payload1);
#endif
}
}
}
if (SR_payload == 1) {
pucch_payload = pucch_payload0;
if (bundling_flag == bundling)
pucch_sel = 2;
} else if (bundling_flag == multiplexing) { // multiplexing + no SR
pucch_payload = (metric1>metric0) ? pucch_payload1 : pucch_payload0;
pucch_sel = (metric1>metric0) ? 1 : 0;
} else { // bundling + no SR
if (n1_pucch1 != -1)
pucch_payload = pucch_payload1;
else if (n1_pucch0 != -1)
pucch_payload = pucch_payload0;
pucch_sel = 2; // indicate that this is a bundled ACK/NAK
}
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d subframe %d ACK/NAK metric 0 %d, metric 1 %d, sel %d, (%d,%d)\n",eNB->Mod_id,
eNB->dlsch[UE_id][0]->rnti,
frame,subframe,
metric0,metric1,pucch_sel,pucch_payload[0],pucch_payload[1]);
#endif
process_HARQ_feedback(UE_id,eNB,proc,
0,// pusch_flag
pucch_payload,
pucch_sel,
SR_payload);
} // TDD
}
if (SR_payload == 1) {
LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d Got SR for PUSCH, transmitting to MAC\n",eNB->Mod_id,
eNB->ulsch[UE_id]->rnti,frame,subframe);
eNB->UE_stats[UE_id].sr_received++;
if (eNB->first_sr[UE_id] == 1) { // this is the first request for uplink after Connection Setup, so clear HARQ process 0 use for Msg4
eNB->first_sr[UE_id] = 0;
eNB->dlsch[UE_id][0]->harq_processes[0]->round=0;
eNB->dlsch[UE_id][0]->harq_processes[0]->status=SCH_IDLE;
LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d First SR\n",
eNB->Mod_id,
eNB->ulsch[UE_id]->rnti,frame,subframe);
}
if (eNB->mac_enabled==1) {
mac_xface->SR_indication(eNB->Mod_id,
eNB->CC_id,
frame,
eNB->dlsch[UE_id][0]->rnti,subframe);
}
}
}
}
void cba_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,int UE_id,int harq_pid) {
uint8_t access_mode;
int num_active_cba_groups;
const int subframe = proc->subframe_rx;
const int frame = proc->frame_rx;
uint16_t rnti=0;
int ret=0;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
if (eNB->ulsch[UE_id]==NULL) return;
num_active_cba_groups = eNB->ulsch[UE_id]->num_active_cba_groups;
if ((num_active_cba_groups > 0) &&
(eNB->ulsch[UE_id]->cba_rnti[UE_id%num_active_cba_groups]>0) &&
(eNB->ulsch[UE_id]->harq_processes[harq_pid]->subframe_cba_scheduling_flag==1)) {
rnti=0;
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d Checking PUSCH/ULSCH CBA Reception for UE %d with cba rnti %x mode %s\n",
eNB->Mod_id,harq_pid,
frame,subframe,
UE_id, (uint16_t)eNB->ulsch[UE_id]->cba_rnti[UE_id%num_active_cba_groups],mode_string[eNB->UE_stats[UE_id].mode]);
#endif
if (eNB->abstraction_flag==0) {
rx_ulsch(eNB,proc,
eNB->UE_stats[UE_id].sector, // this is the effective sector id
UE_id,
eNB->ulsch,
0);
}
#ifdef PHY_ABSTRACTION
else {
rx_ulsch_emul(eNB,proc,
eNB->UE_stats[UE_id].sector, // this is the effective sector id
UE_id);
}
#endif
if (eNB->abstraction_flag == 0) {
ret = ulsch_decoding(eNB,proc,
UE_id,
0, // control_only_flag
eNB->ulsch[UE_id]->harq_processes[harq_pid]->V_UL_DAI,
eNB->ulsch[UE_id]->harq_processes[harq_pid]->nb_rb>20 ? 1 : 0);
}
#ifdef PHY_ABSTRACTION
else {
ret = ulsch_decoding_emul(eNB,
proc,
UE_id,
&rnti);
}
#endif
if (eNB->ulsch[UE_id]->harq_processes[harq_pid]->cqi_crc_status == 1) {
#ifdef DEBUG_PHY_PROC
print_CQI(eNB->ulsch[UE_id]->harq_processes[harq_pid]->o,eNB->ulsch[UE_id]->harq_processes[harq_pid]->uci_format,0,fp->N_RB_DL);
#endif
access_mode = UNKNOWN_ACCESS;
extract_CQI(eNB->ulsch[UE_id]->harq_processes[harq_pid]->o,
eNB->ulsch[UE_id]->harq_processes[harq_pid]->uci_format,
&eNB->UE_stats[UE_id],
fp->N_RB_DL,
&rnti, &access_mode);
eNB->UE_stats[UE_id].rank = eNB->ulsch[UE_id]->harq_processes[harq_pid]->o_RI[0];
}
eNB->ulsch[UE_id]->harq_processes[harq_pid]->subframe_cba_scheduling_flag=0;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->status= SCH_IDLE;
if ((num_active_cba_groups > 0) &&
(UE_id + num_active_cba_groups < NUMBER_OF_UE_MAX) &&
(eNB->ulsch[UE_id+num_active_cba_groups]->cba_rnti[UE_id%num_active_cba_groups] > 0 ) &&
(eNB->ulsch[UE_id+num_active_cba_groups]->num_active_cba_groups> 0)) {
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d harq_pid %d resetting the subframe_scheduling_flag for Ue %d cba groups %d members\n",
eNB->Mod_id,harq_pid,frame,subframe,UE_id,harq_pid,
UE_id+num_active_cba_groups, UE_id%eNB->ulsch[UE_id]->num_active_cba_groups);
#endif
eNB->ulsch[UE_id+num_active_cba_groups]->harq_processes[harq_pid]->subframe_cba_scheduling_flag=1;
eNB->ulsch[UE_id+num_active_cba_groups]->harq_processes[harq_pid]->status= CBA_ACTIVE;
eNB->ulsch[UE_id+num_active_cba_groups]->harq_processes[harq_pid]->TBS=eNB->ulsch[UE_id]->harq_processes[harq_pid]->TBS;
}
if (ret == (1+MAX_TURBO_ITERATIONS)) {
eNB->UE_stats[UE_id].ulsch_round_errors[harq_pid][eNB->ulsch[UE_id]->harq_processes[harq_pid]->round]++;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->phich_active = 1;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->phich_ACK = 0;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->round++;
} // ulsch in error
else {
LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d subframe %d ULSCH received, setting round to 0, PHICH ACK\n",
eNB->Mod_id,harq_pid,
frame,subframe);
eNB->ulsch[UE_id]->harq_processes[harq_pid]->phich_active = 1;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->phich_ACK = 1;
eNB->ulsch[UE_id]->harq_processes[harq_pid]->round = 0;
eNB->UE_stats[UE_id].ulsch_consecutive_errors = 0;
#ifdef DEBUG_PHY_PROC
#ifdef DEBUG_ULSCH
LOG_D(PHY,"[eNB] Frame %d, Subframe %d : ULSCH SDU (RX harq_pid %d) %d bytes:",
frame,subframe,
harq_pid,eNB->ulsch[UE_id]->harq_processes[harq_pid]->TBS>>3);
for (j=0; j<eNB->ulsch[UE_id]->harq_processes[harq_pid]->TBS>>3; j++)
LOG_T(PHY,"%x.",eNB->ulsch[UE_id]->harq_processes[harq_pid]->b[j]);
LOG_T(PHY,"\n");
#endif
#endif
if (access_mode > UNKNOWN_ACCESS) {
LOG_D(PHY,"[eNB %d] Frame %d, Subframe %d : received ULSCH SDU from CBA transmission, UE (%d,%x), CBA (group %d, rnti %x)\n",
eNB->Mod_id, frame,subframe,
UE_id, eNB->ulsch[UE_id]->rnti,
UE_id % eNB->ulsch[UE_id]->num_active_cba_groups, eNB->ulsch[UE_id]->cba_rnti[UE_id%num_active_cba_groups]);
// detect if there is a CBA collision
if ((eNB->cba_last_reception[UE_id%num_active_cba_groups] == 0 ) &&
(eNB->mac_enabled==1)) {
mac_xface->rx_sdu(eNB->Mod_id,
eNB->CC_id,
frame,subframe,
eNB->ulsch[UE_id]->rnti,
eNB->ulsch[UE_id]->harq_processes[harq_pid]->b,
eNB->ulsch[UE_id]->harq_processes[harq_pid]->TBS>>3,
harq_pid,
NULL);
eNB->cba_last_reception[UE_id%num_active_cba_groups]+=1;//(subframe);
} else {
if (eNB->cba_last_reception[UE_id%num_active_cba_groups] == 1 )
LOG_N(PHY,"[eNB%d] Frame %d subframe %d : first CBA collision detected \n ",
eNB->Mod_id,frame,subframe);
LOG_N(PHY,"[eNB%d] Frame %d subframe %d : CBA collision set SR for UE %d in group %d \n ",
eNB->Mod_id,frame,subframe,
eNB->cba_last_reception[UE_id%num_active_cba_groups],UE_id%num_active_cba_groups );
eNB->cba_last_reception[UE_id%num_active_cba_groups]+=1;
mac_xface->SR_indication(eNB->Mod_id,
eNB->CC_id,
frame,
eNB->dlsch[UE_id][0]->rnti,subframe);
}
} // UNKNOWN_ACCESS
} // ULSCH CBA not in error
}
}
typedef struct {
PHY_VARS_eNB *eNB;
int slot;
} fep_task;
void fep0(PHY_VARS_eNB *eNB,int slot) {
eNB_proc_t *proc = &eNB->proc;
LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
int l;
// printf("fep0: slot %d\n",slot);
remove_7_5_kHz(eNB,(slot&1)+(proc->subframe_rx<<1));
for (l=0; l<fp->symbols_per_tti/2; l++) {
slot_fep_ul(fp,
&eNB->common_vars,
l,
(slot&1)+(proc->subframe_rx<<1),
0,
0
);
}
}
extern int oai_exit;
static void *fep_thread(void *param) {
pthread_setname_np( pthread_self(), "UEfep");
PHY_VARS_eNB *eNB = (PHY_VARS_eNB *)param;
eNB_proc_t *proc = &eNB->proc;
while (!oai_exit) {
if (wait_on_condition(&proc->mutex_fep,&proc->cond_fep,&proc->instance_cnt_fep,"fep thread")<0) break;
fep0(eNB,0);
if (release_thread(&proc->mutex_fep,&proc->instance_cnt_fep,"fep thread")<0) break;
if (pthread_cond_signal(&proc->cond_fep) != 0) {
printf("[eNB] ERROR pthread_cond_signal for fep thread exit\n");
exit_fun( "ERROR pthread_cond_signal" );
return NULL;
}
}
return(NULL);
}
void init_fep_thread(PHY_VARS_eNB *eNB,pthread_attr_t *attr_fep) {
eNB_proc_t *proc = &eNB->proc;
proc->instance_cnt_fep = -1;
pthread_mutex_init( &proc->mutex_fep, NULL);
pthread_cond_init( &proc->cond_fep, NULL);
pthread_create(&proc->pthread_fep, attr_fep, fep_thread, (void*)eNB);
}
extern void *td_thread(void*);
void init_td_thread(PHY_VARS_eNB *eNB,pthread_attr_t *attr_td) {
eNB_proc_t *proc = &eNB->proc;
proc->tdp.eNB = eNB;
proc->instance_cnt_td = -1;
pthread_mutex_init( &proc->mutex_td, NULL);
pthread_cond_init( &proc->cond_td, NULL);
pthread_create(&proc->pthread_td, attr_td, td_thread, (void*)&proc->tdp);
}
extern void *te_thread(void*);
void init_te_thread(PHY_VARS_eNB *eNB,pthread_attr_t *attr_te) {
eNB_proc_t *proc = &eNB->proc;
proc->tep.eNB = eNB;
proc->instance_cnt_te = -1;
pthread_mutex_init( &proc->mutex_te, NULL);
pthread_cond_init( &proc->cond_te, NULL);
printf("Creating te_thread\n");
pthread_create(&proc->pthread_te, attr_te, te_thread, (void*)&proc->tep);
}
void eNB_fep_full_2thread(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) {
eNB_proc_t *proc = &eNB->proc;
struct timespec wait;
wait.tv_sec=0;
wait.tv_nsec=5000000L;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_SLOT_FEP,1);
start_meas(&eNB->ofdm_demod_stats);
if (pthread_mutex_timedlock(&proc->mutex_fep,&wait) != 0) {
printf("[eNB] ERROR pthread_mutex_lock for fep thread (IC %d)\n", proc->instance_cnt_fep);
exit_fun( "error locking mutex_fep" );
return;
}
if (proc->instance_cnt_fep==0) {
printf("[eNB] FEP thread busy\n");
exit_fun("FEP thread busy");
pthread_mutex_unlock( &proc->mutex_fep );
return;
}
++proc->instance_cnt_fep;
if (pthread_cond_signal(&proc->cond_fep) != 0) {
printf("[eNB] ERROR pthread_cond_signal for fep thread\n");
exit_fun( "ERROR pthread_cond_signal" );
return;
}
pthread_mutex_unlock( &proc->mutex_fep );
// call second slot in this symbol
fep0(eNB,1);
wait_on_busy_condition(&proc->mutex_fep,&proc->cond_fep,&proc->instance_cnt_fep,"fep thread");
stop_meas(&eNB->ofdm_demod_stats);
}
void eNB_fep_full(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) {
int l;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_SLOT_FEP,1);
start_meas(&eNB->ofdm_demod_stats);
remove_7_5_kHz(eNB,proc_rxtx->subframe_rx<<1);
remove_7_5_kHz(eNB,1+(proc_rxtx->subframe_rx<<1));
for (l=0; l<fp->symbols_per_tti/2; l++) {
slot_fep_ul(fp,
&eNB->common_vars,
l,
(proc_rxtx->subframe_rx)<<1,
0,
0
);
slot_fep_ul(fp,
&eNB->common_vars,
l,
1+((proc_rxtx->subframe_rx)<<1),
0,
0
);
}
stop_meas(&eNB->ofdm_demod_stats);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_SLOT_FEP,0);
if (eNB->node_function == NGFI_RRU_IF4p5) {
/// **** send_IF4 of rxdataF to RCC (no prach now) **** ///
LOG_D(PHY,"send_IF4p5 (PULFFT): frame %d, subframe %d\n",proc_rxtx->frame_rx,proc_rxtx->subframe_rx);
send_IF4p5(eNB, proc_rxtx->frame_rx, proc_rxtx->subframe_rx, IF4p5_PULFFT, 0);
start_fh_prev = start_fh;
start_fh_prev_sf = start_fh_sf;
clock_gettime( CLOCK_MONOTONIC, &start_fh);
start_fh_sf = proc_rxtx->subframe_rx;
}
}
void eNB_fep_rru_if5(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) {
eNB_proc_t *proc=&eNB->proc;
uint8_t seqno=0;
/// **** send_IF5 of rxdata to BBU **** ///
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5, 1 );
send_IF5(eNB, proc->timestamp_rx, proc->subframe_rx, &seqno, IF5_RRH_GW_UL);
start_fh_prev = start_fh;
start_fh_prev_sf = start_fh_sf;
clock_gettime( CLOCK_MONOTONIC, &start_fh);
start_fh_sf = proc->subframe_rx;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5, 0 );
}
void do_prach(PHY_VARS_eNB *eNB,int frame,int subframe) {
eNB_proc_t *proc = &eNB->proc;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
// check if we have to detect PRACH first
if (is_prach_subframe(fp,frame,subframe)>0) {
/* accept some delay in processing - up to 5ms */
int i;
for (i = 0; i < 10 && proc->instance_cnt_prach == 0; i++) {
LOG_W(PHY,"[eNB] Frame %d Subframe %d, eNB PRACH thread busy (IC %d)!!\n", frame,subframe,proc->instance_cnt_prach);
usleep(500);
}
if (proc->instance_cnt_prach == 0) {
exit_fun( "PRACH thread busy" );
return;
}
// wake up thread for PRACH RX
if (pthread_mutex_lock(&proc->mutex_prach) != 0) {
LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB PRACH thread %d (IC %d)\n", proc->thread_index, proc->instance_cnt_prach);
exit_fun( "error locking mutex_prach" );
return;
}
++proc->instance_cnt_prach;
// set timing for prach thread
proc->frame_prach = frame;
proc->subframe_prach = subframe;
// the thread can now be woken up
if (pthread_cond_signal(&proc->cond_prach) != 0) {
LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB PRACH thread %d\n", proc->thread_index);
exit_fun( "ERROR pthread_cond_signal" );
return;
}
pthread_mutex_unlock( &proc->mutex_prach );
}
}
void phy_procedures_eNB_common_RX(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc){
// eNB_proc_t *proc = &eNB->proc;
LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
const int subframe = proc->subframe_rx;
const int frame = proc->frame_rx;
int offset = (eNB->single_thread_flag==1) ? 0 : (subframe&1);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB+offset, proc->frame_rx );
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_ENB+offset, proc->subframe_rx );
if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) {
if (eNB->node_function == NGFI_RRU_IF4p5) {
/// **** in TDD during DL send_IF4 of ULTICK to RCC **** ///
send_IF4p5(eNB, proc->frame_rx, proc->subframe_rx, IF4p5_PULTICK, 0);
}
return;
}
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON+offset, 1 );
start_meas(&eNB->phy_proc_rx);
LOG_D(PHY,"[eNB %d] Frame %d: Doing phy_procedures_eNB_common_RX(%d)\n",eNB->Mod_id,frame,subframe);
if (eNB->fep) eNB->fep(eNB,proc);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON+offset, 0 );
}
void phy_procedures_eNB_uespec_RX(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,const relaying_type_t r_type)
{
//RX processing for ue-specific resources (i
UNUSED(r_type);
uint32_t ret=0,i,j,k;
uint32_t harq_pid, harq_idx, round;
uint8_t nPRS;
int sync_pos;
uint16_t rnti=0;
uint8_t access_mode;
LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
const int subframe = proc->subframe_rx;
const int frame = proc->frame_rx;
int offset = eNB->CC_id;//(proc == &eNB->proc.proc_rxtx[0]) ? 0 : 1;
uint16_t srsPeriodicity;
uint16_t srsOffset;
uint16_t do_srs=0;
uint16_t is_srs_pos=0;
T(T_ENB_PHY_UL_TICK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe));
T(T_ENB_PHY_INPUT_SIGNAL, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(0),
T_BUFFER(&eNB->common_vars.rxdata[0][0][subframe*eNB->frame_parms.samples_per_tti],
eNB->frame_parms.samples_per_tti * 4));
if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) return;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_UESPEC+offset, 1 );
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d] Frame %d: Doing phy_procedures_eNB_uespec_RX(%d)\n",eNB->Mod_id,frame, subframe);
#endif
eNB->rb_mask_ul[0]=0;
eNB->rb_mask_ul[1]=0;
eNB->rb_mask_ul[2]=0;
eNB->rb_mask_ul[3]=0;
// Check for active processes in current subframe
harq_pid = subframe2harq_pid(fp,
frame,subframe);
// reset the cba flag used for collision detection
for (i=0; i < NUM_MAX_CBA_GROUP; i++) {
eNB->cba_last_reception[i]=0;
}
is_srs_pos = is_srs_occasion_common(fp,frame,subframe);
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
// Do SRS processing
// check if there is SRS and we have to use shortened format
// TODO: check for exceptions in transmission of SRS together with ACK/NACK
do_srs=0;
if (is_srs_pos && eNB->soundingrs_ul_config_dedicated[i].srsConfigDedicatedSetup ) {
compute_srs_pos(fp->frame_type, eNB->soundingrs_ul_config_dedicated[i].srs_ConfigIndex, &srsPeriodicity, &srsOffset);
if (((10*frame+subframe) % srsPeriodicity) == srsOffset) {
do_srs = 1;
}
}
if (do_srs==1) {
if (lte_srs_channel_estimation(fp,
&eNB->common_vars,
&eNB->srs_vars[i],
&eNB->soundingrs_ul_config_dedicated[i],
subframe,
0/*eNB_id*/)) {
LOG_E(PHY,"problem processing SRS\n");
}
}
// Do PUCCH processing
pucch_procedures(eNB,proc,i,harq_pid, do_srs);
// check for Msg3
if (eNB->mac_enabled==1) {
if (eNB->UE_stats[i].mode == RA_RESPONSE) {
process_Msg3(eNB,proc,i,harq_pid);
}
}
eNB->pusch_stats_rb[i][(frame*10)+subframe] = -63;
eNB->pusch_stats_round[i][(frame*10)+subframe] = 0;
eNB->pusch_stats_mcs[i][(frame*10)+subframe] = -63;
if ((eNB->ulsch[i]) &&
(eNB->ulsch[i]->rnti>0) &&
(eNB->ulsch[i]->harq_processes[harq_pid]->subframe_scheduling_flag==1)) {
// UE is has ULSCH scheduling
round = eNB->ulsch[i]->harq_processes[harq_pid]->round;
for (int rb=0;
rb<=eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb;
rb++) {
int rb2 = rb+eNB->ulsch[i]->harq_processes[harq_pid]->first_rb;
eNB->rb_mask_ul[rb2>>5] |= (1<<(rb2&31));
}
if (eNB->ulsch[i]->Msg3_flag == 1) {
LOG_D(PHY,"[eNB %d] frame %d, subframe %d: Scheduling ULSCH Reception for Msg3 in Sector %d\n",
eNB->Mod_id,
frame,
subframe,
eNB->UE_stats[i].sector);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_MSG3,1);
} else {
LOG_D(PHY,"[eNB %d] frame %d, subframe %d: Scheduling ULSCH Reception for UE %d Mode %s\n",
eNB->Mod_id,
frame,
subframe,
i,
mode_string[eNB->UE_stats[i].mode]);
}
nPRS = fp->pusch_config_common.ul_ReferenceSignalsPUSCH.nPRS[subframe<<1];
eNB->ulsch[i]->cyclicShift = (eNB->ulsch[i]->harq_processes[harq_pid]->n_DMRS2 + fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift +
nPRS)%12;
if (fp->frame_type == FDD ) {
int sf = (subframe<4) ? (subframe+6) : (subframe-4);
if (eNB->dlsch[i][0]->subframe_tx[sf]>0) { // we have downlink transmission
eNB->ulsch[i]->harq_processes[harq_pid]->O_ACK = 1;
} else {
eNB->ulsch[i]->harq_processes[harq_pid]->O_ACK = 0;
}
}
LOG_D(PHY,
"[eNB %d][PUSCH %d] Frame %d Subframe %d Demodulating PUSCH: dci_alloc %d, rar_alloc %d, round %d, first_rb %d, nb_rb %d, mcs %d, TBS %d, rv %d, cyclic_shift %d (n_DMRS2 %d, cyclicShift_common %d, nprs %d), O_ACK %d \n",
eNB->Mod_id,harq_pid,frame,subframe,
eNB->ulsch[i]->harq_processes[harq_pid]->dci_alloc,
eNB->ulsch[i]->harq_processes[harq_pid]->rar_alloc,
eNB->ulsch[i]->harq_processes[harq_pid]->round,
eNB->ulsch[i]->harq_processes[harq_pid]->first_rb,
eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb,
eNB->ulsch[i]->harq_processes[harq_pid]->mcs,
eNB->ulsch[i]->harq_processes[harq_pid]->TBS,
eNB->ulsch[i]->harq_processes[harq_pid]->rvidx,
eNB->ulsch[i]->cyclicShift,
eNB->ulsch[i]->harq_processes[harq_pid]->n_DMRS2,
fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift,
nPRS,
eNB->ulsch[i]->harq_processes[harq_pid]->O_ACK);
eNB->pusch_stats_rb[i][(frame*10)+subframe] = eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb;
eNB->pusch_stats_round[i][(frame*10)+subframe] = eNB->ulsch[i]->harq_processes[harq_pid]->round;
eNB->pusch_stats_mcs[i][(frame*10)+subframe] = eNB->ulsch[i]->harq_processes[harq_pid]->mcs;
start_meas(&eNB->ulsch_demodulation_stats);
if (eNB->abstraction_flag==0) {
rx_ulsch(eNB,proc,
eNB->UE_stats[i].sector, // this is the effective sector id
i,
eNB->ulsch,
0);
}
#ifdef PHY_ABSTRACTION
else {
rx_ulsch_emul(eNB,proc,
eNB->UE_stats[i].sector, // this is the effective sector id
i);
}
#endif
stop_meas(&eNB->ulsch_demodulation_stats);
start_meas(&eNB->ulsch_decoding_stats);
if (eNB->abstraction_flag == 0) {
ret = ulsch_decoding(eNB,proc,
i,
0, // control_only_flag
eNB->ulsch[i]->harq_processes[harq_pid]->V_UL_DAI,
eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb>20 ? 1 : 0);
}
#ifdef PHY_ABSTRACTION
else {
ret = ulsch_decoding_emul(eNB,
proc,
i,
&rnti);
}
#endif
stop_meas(&eNB->ulsch_decoding_stats);
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d RNTI %x RX power (%d,%d) RSSI (%d,%d) N0 (%d,%d) dB ACK (%d,%d), decoding iter %d\n",
eNB->Mod_id,harq_pid,
frame,subframe,
eNB->ulsch[i]->rnti,
dB_fixed(eNB->pusch_vars[i]->ulsch_power[0]),
dB_fixed(eNB->pusch_vars[i]->ulsch_power[1]),
eNB->UE_stats[i].UL_rssi[0],
eNB->UE_stats[i].UL_rssi[1],
eNB->measurements->n0_power_dB[0],
eNB->measurements->n0_power_dB[1],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[0],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[1],
ret);
//compute the expected ULSCH RX power (for the stats)
eNB->ulsch[(uint32_t)i]->harq_processes[harq_pid]->delta_TF =
get_hundred_times_delta_IF_eNB(eNB,i,harq_pid, 0); // 0 means bw_factor is not considered
eNB->UE_stats[i].ulsch_decoding_attempts[harq_pid][eNB->ulsch[i]->harq_processes[harq_pid]->round]++;
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d harq_pid %d Clearing subframe_scheduling_flag\n",
eNB->Mod_id,harq_pid,frame,subframe,i,harq_pid);
#endif
eNB->ulsch[i]->harq_processes[harq_pid]->subframe_scheduling_flag=0;
if (eNB->ulsch[i]->harq_processes[harq_pid]->cqi_crc_status == 1) {
#ifdef DEBUG_PHY_PROC
//if (((frame%10) == 0) || (frame < 50))
print_CQI(eNB->ulsch[i]->harq_processes[harq_pid]->o,eNB->ulsch[i]->harq_processes[harq_pid]->uci_format,0,fp->N_RB_DL);
#endif
extract_CQI(eNB->ulsch[i]->harq_processes[harq_pid]->o,
eNB->ulsch[i]->harq_processes[harq_pid]->uci_format,
&eNB->UE_stats[i],
fp->N_RB_DL,
&rnti, &access_mode);
eNB->UE_stats[i].rank = eNB->ulsch[i]->harq_processes[harq_pid]->o_RI[0];
}
if (eNB->ulsch[i]->Msg3_flag == 1)
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_MSG3,0);
if (ret == (1+MAX_TURBO_ITERATIONS)) {
T(T_ENB_PHY_ULSCH_UE_NACK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(i), T_INT(eNB->ulsch[i]->rnti),
T_INT(harq_pid));
eNB->UE_stats[i].ulsch_round_errors[harq_pid][eNB->ulsch[i]->harq_processes[harq_pid]->round]++;
eNB->ulsch[i]->harq_processes[harq_pid]->phich_active = 1;
eNB->ulsch[i]->harq_processes[harq_pid]->phich_ACK = 0;
eNB->ulsch[i]->harq_processes[harq_pid]->round++;
LOG_D(PHY,"[eNB][PUSCH %d] Increasing to round %d\n",harq_pid,eNB->ulsch[i]->harq_processes[harq_pid]->round);
if (eNB->ulsch[i]->Msg3_flag == 1) {
LOG_D(PHY,"[eNB %d/%d][RAPROC] frame %d, subframe %d, UE %d: Error receiving ULSCH (Msg3), round %d/%d\n",
eNB->Mod_id,
eNB->CC_id,
frame,subframe, i,
eNB->ulsch[i]->harq_processes[harq_pid]->round-1,
fp->maxHARQ_Msg3Tx-1);
/*dump_ulsch(eNB,proc,i);
exit(-1);*/
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d RNTI %x RX power (%d,%d) RSSI (%d,%d) N0 (%d,%d) dB ACK (%d,%d), decoding iter %d\n",
eNB->Mod_id,harq_pid,
frame,subframe,
eNB->ulsch[i]->rnti,
dB_fixed(eNB->pusch_vars[i]->ulsch_power[0]),
dB_fixed(eNB->pusch_vars[i]->ulsch_power[1]),
eNB->UE_stats[i].UL_rssi[0],
eNB->UE_stats[i].UL_rssi[1],
eNB->measurements->n0_power_dB[0],
eNB->measurements->n0_power_dB[1],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[0],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[1],
ret);
if (eNB->ulsch[i]->harq_processes[harq_pid]->round ==
fp->maxHARQ_Msg3Tx) {
LOG_D(PHY,"[eNB %d][RAPROC] maxHARQ_Msg3Tx reached, abandoning RA procedure for UE %d\n",
eNB->Mod_id, i);
eNB->UE_stats[i].mode = PRACH;
if (eNB->mac_enabled==1) {
mac_xface->cancel_ra_proc(eNB->Mod_id,
eNB->CC_id,
frame,
eNB->UE_stats[i].crnti);
}
mac_phy_remove_ue(eNB->Mod_id,eNB->UE_stats[i].crnti);
eNB->ulsch[(uint32_t)i]->Msg3_active = 0;
//eNB->ulsch[i]->harq_processes[harq_pid]->phich_active = 0;
} else {
// activate retransmission for Msg3 (signalled to UE PHY by PHICH (not MAC/DCI)
eNB->ulsch[(uint32_t)i]->Msg3_active = 1;
get_Msg3_alloc_ret(fp,
subframe,
frame,
&eNB->ulsch[i]->Msg3_frame,
&eNB->ulsch[i]->Msg3_subframe);
mac_xface->set_msg3_subframe(eNB->Mod_id, eNB->CC_id, frame, subframe, eNB->ulsch[i]->rnti,
eNB->ulsch[i]->Msg3_frame, eNB->ulsch[i]->Msg3_subframe);
T(T_ENB_PHY_MSG3_ALLOCATION, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe),
T_INT(i), T_INT(eNB->ulsch[i]->rnti), T_INT(0 /* 0 is for retransmission*/),
T_INT(eNB->ulsch[i]->Msg3_frame), T_INT(eNB->ulsch[i]->Msg3_subframe));
}
LOG_D(PHY,"[eNB] Frame %d, Subframe %d: Msg3 in error, i = %d \n", frame,subframe,i);
} // This is Msg3 error
else { //normal ULSCH
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d Error receiving ULSCH, round %d/%d (ACK %d,%d)\n",
eNB->Mod_id,harq_pid,
frame,subframe, i,
eNB->ulsch[i]->harq_processes[harq_pid]->round-1,
eNB->ulsch[i]->Mlimit,
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[0],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[1]);
#if defined(MESSAGE_CHART_GENERATOR_PHY)
MSC_LOG_RX_DISCARDED_MESSAGE(
MSC_PHY_ENB,MSC_PHY_UE,
NULL,0,
"%05u:%02u ULSCH received rnti %x harq id %u round %d",
frame,subframe,
eNB->ulsch[i]->rnti,harq_pid,
eNB->ulsch[i]->harq_processes[harq_pid]->round-1
);
#endif
if (eNB->ulsch[i]->harq_processes[harq_pid]->round== eNB->ulsch[i]->Mlimit) {
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d UE %d ULSCH Mlimit %d reached\n",
eNB->Mod_id,harq_pid,
frame,subframe, i,
eNB->ulsch[i]->Mlimit);
eNB->ulsch[i]->harq_processes[harq_pid]->round=0;
eNB->ulsch[i]->harq_processes[harq_pid]->phich_active=0;
eNB->UE_stats[i].ulsch_errors[harq_pid]++;
eNB->UE_stats[i].ulsch_consecutive_errors++;
/*if (eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb > 20) {
dump_ulsch(eNB,proc,i);
exit(-1);
}*/
// indicate error to MAC
if (eNB->mac_enabled == 1)
mac_xface->rx_sdu(eNB->Mod_id,
eNB->CC_id,
frame,subframe,
eNB->ulsch[i]->rnti,
NULL,
0,
harq_pid,
&eNB->ulsch[i]->Msg3_flag);
}
}
} // ulsch in error
else {
T(T_ENB_PHY_ULSCH_UE_ACK, T_INT(eNB->Mod_id), T_INT(frame), T_INT(subframe), T_INT(i), T_INT(eNB->ulsch[i]->rnti),
T_INT(harq_pid));
if (eNB->ulsch[i]->Msg3_flag == 1) {
LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d subframe %d ULSCH received, setting round to 0, PHICH ACK\n",
eNB->Mod_id,harq_pid,
frame,subframe);
LOG_D(PHY,"[eNB %d][PUSCH %d] frame %d subframe %d RNTI %x RX power (%d,%d) RSSI (%d,%d) N0 (%d,%d) dB ACK (%d,%d), decoding iter %d\n",
eNB->Mod_id,harq_pid,
frame,subframe,
eNB->ulsch[i]->rnti,
dB_fixed(eNB->pusch_vars[i]->ulsch_power[0]),
dB_fixed(eNB->pusch_vars[i]->ulsch_power[1]),
eNB->UE_stats[i].UL_rssi[0],
eNB->UE_stats[i].UL_rssi[1],
eNB->measurements->n0_power_dB[0],
eNB->measurements->n0_power_dB[1],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[0],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[1],
ret);
}
#if defined(MESSAGE_CHART_GENERATOR_PHY)
MSC_LOG_RX_MESSAGE(
MSC_PHY_ENB,MSC_PHY_UE,
NULL,0,
"%05u:%02u ULSCH received rnti %x harq id %u",
frame,subframe,
eNB->ulsch[i]->rnti,harq_pid
);
#endif
for (j=0; j<fp->nb_antennas_rx; j++)
//this is the RSSI per RB
eNB->UE_stats[i].UL_rssi[j] =
dB_fixed(eNB->pusch_vars[i]->ulsch_power[j]*
(eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb*12)/
fp->ofdm_symbol_size) -
eNB->rx_total_gain_dB -
hundred_times_log10_NPRB[eNB->ulsch[i]->harq_processes[harq_pid]->nb_rb-1]/100 -
get_hundred_times_delta_IF_eNB(eNB,i,harq_pid, 0)/100;
eNB->ulsch[i]->harq_processes[harq_pid]->phich_active = 1;
eNB->ulsch[i]->harq_processes[harq_pid]->phich_ACK = 1;
eNB->ulsch[i]->harq_processes[harq_pid]->round = 0;
eNB->UE_stats[i].ulsch_consecutive_errors = 0;
if (eNB->ulsch[i]->Msg3_flag == 1) {
if (eNB->mac_enabled==1) {
LOG_I(PHY,"[eNB %d][RAPROC] Frame %d Terminating ra_proc for harq %d, UE %d\n",
eNB->Mod_id,
frame,harq_pid,i);
if (eNB->mac_enabled)
mac_xface->rx_sdu(eNB->Mod_id,
eNB->CC_id,
frame,subframe,
eNB->ulsch[i]->rnti,
eNB->ulsch[i]->harq_processes[harq_pid]->b,
eNB->ulsch[i]->harq_processes[harq_pid]->TBS>>3,
harq_pid,
&eNB->ulsch[i]->Msg3_flag);
// one-shot msg3 detection by MAC: empty PDU (e.g. CRNTI)
if (eNB->ulsch[i]->Msg3_flag == 0 ) {
eNB->UE_stats[i].mode = PRACH;
mac_xface->cancel_ra_proc(eNB->Mod_id,
eNB->CC_id,
frame,
eNB->UE_stats[i].crnti);
mac_phy_remove_ue(eNB->Mod_id,eNB->UE_stats[i].crnti);
eNB->ulsch[(uint32_t)i]->Msg3_active = 0;
} // Msg3_flag == 0
} // mac_enabled==1
eNB->UE_stats[i].mode = PUSCH;
eNB->ulsch[i]->Msg3_flag = 0;
LOG_D(PHY,"[eNB %d][RAPROC] Frame %d : RX Subframe %d Setting UE %d mode to PUSCH\n",eNB->Mod_id,frame,subframe,i);
for (k=0; k<8; k++) { //harq_processes
for (j=0; j<eNB->dlsch[i][0]->Mlimit; j++) {
eNB->UE_stats[i].dlsch_NAK[k][j]=0;
eNB->UE_stats[i].dlsch_ACK[k][j]=0;
eNB->UE_stats[i].dlsch_trials[k][j]=0;
}
eNB->UE_stats[i].dlsch_l2_errors[k]=0;
eNB->UE_stats[i].ulsch_errors[k]=0;
eNB->UE_stats[i].ulsch_consecutive_errors=0;
for (j=0; j<eNB->ulsch[i]->Mlimit; j++) {
eNB->UE_stats[i].ulsch_decoding_attempts[k][j]=0;
eNB->UE_stats[i].ulsch_decoding_attempts_last[k][j]=0;
eNB->UE_stats[i].ulsch_round_errors[k][j]=0;
eNB->UE_stats[i].ulsch_round_fer[k][j]=0;
}
}
eNB->UE_stats[i].dlsch_sliding_cnt=0;
eNB->UE_stats[i].dlsch_NAK_round0=0;
eNB->UE_stats[i].dlsch_mcs_offset=0;
} // Msg3_flag==1
else { // Msg3_flag == 0
#ifdef DEBUG_PHY_PROC
#ifdef DEBUG_ULSCH
LOG_D(PHY,"[eNB] Frame %d, Subframe %d : ULSCH SDU (RX harq_pid %d) %d bytes:",frame,subframe,
harq_pid,eNB->ulsch[i]->harq_processes[harq_pid]->TBS>>3);
for (j=0; j<eNB->ulsch[i]->harq_processes[harq_pid]->TBS>>3; j++)
LOG_T(PHY,"%x.",eNB->ulsch[i]->harq_processes[harq_pid]->b[j]);
LOG_T(PHY,"\n");
#endif
#endif
if (eNB->mac_enabled==1) {
mac_xface->rx_sdu(eNB->Mod_id,
eNB->CC_id,
frame,subframe,
eNB->ulsch[i]->rnti,
eNB->ulsch[i]->harq_processes[harq_pid]->b,
eNB->ulsch[i]->harq_processes[harq_pid]->TBS>>3,
harq_pid,
NULL);
#ifdef LOCALIZATION
start_meas(&eNB->localization_stats);
aggregate_eNB_UE_localization_stats(eNB,
i,
frame,
subframe,
get_hundred_times_delta_IF_eNB(eNB,i,harq_pid, 1)/100);
stop_meas(&eNB->localization_stats);
#endif
} // mac_enabled==1
} // Msg3_flag == 0
// estimate timing advance for MAC
if (eNB->abstraction_flag == 0) {
sync_pos = lte_est_timing_advance_pusch(eNB,i);
eNB->UE_stats[i].timing_advance_update = sync_pos - fp->nb_prefix_samples/4; //to check
}
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d] frame %d, subframe %d: user %d: timing advance = %d\n",
eNB->Mod_id,
frame, subframe,
i,
eNB->UE_stats[i].timing_advance_update);
#endif
} // ulsch not in error
// process HARQ feedback
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d][PDSCH %x] Frame %d subframe %d, Processing HARQ feedback for UE %d (after PUSCH)\n",eNB->Mod_id,
eNB->dlsch[i][0]->rnti,
frame,subframe,
i);
#endif
process_HARQ_feedback(i,
eNB,proc,
1, // pusch_flag
0,
0,
0);
#ifdef DEBUG_PHY_PROC
LOG_D(PHY,"[eNB %d] Frame %d subframe %d, sect %d: received ULSCH harq_pid %d for UE %d, ret = %d, CQI CRC Status %d, ACK %d,%d, ulsch_errors %d/%d\n",
eNB->Mod_id,frame,subframe,
eNB->UE_stats[i].sector,
harq_pid,
i,
ret,
eNB->ulsch[i]->harq_processes[harq_pid]->cqi_crc_status,
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[0],
eNB->ulsch[i]->harq_processes[harq_pid]->o_ACK[1],
eNB->UE_stats[i].ulsch_errors[harq_pid],
eNB->UE_stats[i].ulsch_decoding_attempts[harq_pid][0]);
#endif
// dump stats to VCD
if (i==0) {
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS0+harq_pid,eNB->pusch_stats_mcs[0][(frame*10)+subframe]);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB0+harq_pid,eNB->pusch_stats_rb[0][(frame*10)+subframe]);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND0+harq_pid,eNB->pusch_stats_round[0][(frame*10)+subframe]);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI0+harq_pid,dB_fixed(eNB->pusch_vars[0]->ulsch_power[0]));
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES0+harq_pid,ret);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN0+harq_pid,(frame*10)+subframe);
}
} // ulsch[0] && ulsch[0]->rnti>0 && ulsch[0]->subframe_scheduling_flag == 1
// update ULSCH statistics for tracing
if ((frame % 100 == 0) && (subframe == 4)) {
for (harq_idx=0; harq_idx<8; harq_idx++) {
for (round=0; round<eNB->ulsch[i]->Mlimit; round++) {
if ((eNB->UE_stats[i].ulsch_decoding_attempts[harq_idx][round] -
eNB->UE_stats[i].ulsch_decoding_attempts_last[harq_idx][round]) != 0) {
eNB->UE_stats[i].ulsch_round_fer[harq_idx][round] =
(100*(eNB->UE_stats[i].ulsch_round_errors[harq_idx][round] -
eNB->UE_stats[i].ulsch_round_errors_last[harq_idx][round]))/
(eNB->UE_stats[i].ulsch_decoding_attempts[harq_idx][round] -
eNB->UE_stats[i].ulsch_decoding_attempts_last[harq_idx][round]);
} else {
eNB->UE_stats[i].ulsch_round_fer[harq_idx][round] = 0;
}
eNB->UE_stats[i].ulsch_decoding_attempts_last[harq_idx][round] =
eNB->UE_stats[i].ulsch_decoding_attempts[harq_idx][round];
eNB->UE_stats[i].ulsch_round_errors_last[harq_idx][round] =
eNB->UE_stats[i].ulsch_round_errors[harq_idx][round];
}
}
}
if ((frame % 100 == 0) && (subframe==4)) {
eNB->UE_stats[i].dlsch_bitrate = (eNB->UE_stats[i].total_TBS -
eNB->UE_stats[i].total_TBS_last);
eNB->UE_stats[i].total_TBS_last = eNB->UE_stats[i].total_TBS;
}
// CBA (non-LTE)
cba_procedures(eNB,proc,i,harq_pid);
} // loop i=0 ... NUMBER_OF_UE_MAX-1
if (eNB->abstraction_flag == 0) {
lte_eNB_I0_measurements(eNB,
subframe,
0,
eNB->first_run_I0_measurements);
eNB->first_run_I0_measurements = 0;
}
#ifdef PHY_ABSTRACTION
else {
lte_eNB_I0_measurements_emul(eNB,
0);
}
#endif
//}
#ifdef EMOS
phy_procedures_emos_eNB_RX(subframe,eNB);
#endif
#if defined(FLEXRAN_AGENT_SB_IF)
#ifndef DISABLE_SF_TRIGGER
//Send subframe trigger to the controller
if (mac_agent_registered[eNB->Mod_id]) {
agent_mac_xface[eNB->Mod_id]->flexran_agent_send_sf_trigger(eNB->Mod_id);
}
#endif
#endif
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_UESPEC+offset, 0 );
stop_meas(&eNB->phy_proc_rx);
}
#undef DEBUG_PHY_PROC
#if defined(Rel10) || defined(Rel14)
int phy_procedures_RN_eNB_TX(unsigned char last_slot, unsigned char next_slot, relaying_type_t r_type)
{
int do_proc=0;// do nothing
switch(r_type) {
case no_relay:
do_proc= no_relay; // perform the normal eNB operation
break;
case multicast_relay:
if (((next_slot >>1) < 6) || ((next_slot >>1) > 8))
do_proc = 0; // do nothing
else // SF#6, SF#7 and SF#8
do_proc = multicast_relay; // do PHY procedures eNB TX
break;
default: // should'not be here
LOG_W(PHY,"Not supported relay type %d, do nothing\n", r_type);
do_proc=0;
break;
}
return do_proc;
}
#endif
|
718670.c | /*
* Copyright 2014-2016 CyberVision, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "kaa_private.h"
#include "kaa_user.h"
#include "kaa_user_private.h"
#include <stdint.h>
#include <string.h>
#include "platform/stdio.h"
#include "platform/sock.h"
#include "kaa_defaults.h"
#include "platform/ext_sha.h"
#include "kaa_status.h"
#include "kaa_channel_manager.h"
#include "kaa_platform_common.h"
#include "kaa_platform_utils.h"
#include "utilities/kaa_mem.h"
#include "utilities/kaa_log.h"
#include "collections/kaa_list.h"
#include "kaa_common.h"
#define KAA_USER_RECEIVE_UPDATES_FLAG 0x01
#define EXTERNAL_SYSTEM_AUTH_FIELD 0x00
#define EXTERNAL_SYSTEM_ENDPOINT_ATTACH_FIELD 0x01
#define EXTERNAL_SYSTEM_ENDPOINT_DETACH_FIELD 0x02
#define USER_SYNC_ENDPOINT_ID_OPTION 0x01
typedef struct {
char *user_external_id;
size_t user_external_id_len;
char *user_access_token;
size_t user_access_token_len;
char *user_verifier_token;
size_t user_verifier_token_len;
} user_info_t;
typedef struct {
uint16_t request_id;
char *access_token;
size_t access_token_length;
kaa_endpoint_id endpoint_token;
bool is_waiting_response;
kaa_endpoint_status_listener_t *listener;
} kaa_endpoint_info_t;
struct kaa_user_manager_t {
kaa_attachment_status_listeners_t attachment_listeners; /*!< Client code-defined user attachment listeners */
user_info_t *user_info; /*!< User credentials */
bool is_waiting_user_attach_response;
kaa_list_t *attach_endpoints; /*!< Endpoints attach list*/
kaa_list_t *detach_endpoints; /*!< Endpoints detach list */
uint16_t endpoint_request_counter; /*!< Endpoints counter of request id*/
kaa_status_t *status; /*!< Reference to global status */
kaa_channel_manager_t *channel_manager; /*!< Reference to global channel manager */
kaa_logger_t *logger;
};
typedef enum {
USER_RESULT_SUCCESS = 0x00,
USER_RESULT_FAILURE = 0x01
} user_sync_result_t;
typedef enum {
USER_ATTACH_RESPONSE_FIELD = 0,
USER_ATTACH_NOTIFICATION_FIELD = 1,
USER_DETACH_NOTIFICATION_FIELD = 2,
ENDPOINT_ATTACH_RESPONSES_FIELD = 3,
ENDPOINT_DETACH_RESPONSES_FIELD = 4
} user_server_sync_field_t;
static kaa_extension_id user_sync_services[1] = {KAA_EXTENSION_USER};
kaa_error_t kaa_extension_user_init(kaa_context_t *kaa_context, void **context)
{
kaa_error_t error = kaa_user_manager_create(&kaa_context->user_manager, kaa_context->status->status_instance,
kaa_context->channel_manager, kaa_context->logger);
*context = kaa_context->user_manager;
return error;
}
kaa_error_t kaa_extension_user_deinit(void *context)
{
kaa_user_manager_destroy(context);
return KAA_ERR_NONE;
}
kaa_error_t kaa_extension_user_request_get_size(void *context, size_t *expected_size)
{
return kaa_user_request_get_size(context, expected_size);
}
kaa_error_t kaa_extension_user_request_serialize(void *context, uint32_t request_id,
uint8_t *buffer, size_t *size, bool *need_resync)
{
(void)request_id;
// TODO(KAA-982): Use asserts
if (!context || !size || !need_resync) {
return KAA_ERR_BADPARAM;
}
*need_resync = true;
size_t size_needed;
kaa_error_t error = kaa_user_request_get_size(context, &size_needed);
if (error) {
return error;
}
if (!buffer || *size < size_needed) {
*size = size_needed;
return KAA_ERR_BUFFER_IS_NOT_ENOUGH;
}
*size = size_needed;
kaa_platform_message_writer_t writer = KAA_MESSAGE_WRITER(buffer, *size);
error = kaa_user_request_serialize(context, &writer);
if (error) {
return error;
}
*size = writer.current - buffer;
return KAA_ERR_NONE;
}
kaa_error_t kaa_extension_user_server_sync(void *context, uint32_t request_id,
uint16_t extension_options, const uint8_t *buffer, size_t size)
{
(void)request_id;
// TODO(KAA-982): Use asserts
if (!context || !buffer) {
return KAA_ERR_BADPARAM;
}
kaa_platform_message_reader_t reader = KAA_MESSAGE_READER(buffer, size);
return kaa_user_handle_server_sync(context, &reader, extension_options, size);
}
static void dtor_endpoint_info(void *data)
{
KAA_RETURN_IF_NIL(data, );
kaa_endpoint_info_t *endpoint_info = (kaa_endpoint_info_t*)data;
if(endpoint_info->access_token)
KAA_FREE(endpoint_info->access_token);
KAA_FREE(endpoint_info);
}
static bool match_predicate_endpoint_info(void *data, void *context)
{
KAA_RETURN_IF_NIL2(data, context, false);
kaa_endpoint_info_t *endpoint_item = (kaa_endpoint_info_t*)data;
uint16_t request_id = *(uint16_t*)context;
return request_id == endpoint_item->request_id;
}
static void destroy_user_info(user_info_t *user_info)
{
KAA_RETURN_IF_NIL(user_info, );
if (user_info->user_external_id)
KAA_FREE(user_info->user_external_id);
if (user_info->user_access_token)
KAA_FREE(user_info->user_access_token);
if (user_info->user_verifier_token)
KAA_FREE(user_info->user_verifier_token);
KAA_FREE(user_info);
}
static user_info_t *create_user_info(const char *external_id, const char *user_access_token, const char *user_verifier_token)
{
KAA_RETURN_IF_NIL3(external_id, user_access_token, user_verifier_token, NULL);
user_info_t *user_info = (user_info_t *) KAA_CALLOC(1, sizeof(user_info_t));
KAA_RETURN_IF_NIL(user_info, NULL);
user_info->user_external_id_len = strlen(external_id);
user_info->user_access_token_len = strlen(user_access_token);
user_info->user_verifier_token_len = strlen(user_verifier_token);
user_info->user_external_id = (char *) KAA_MALLOC((user_info->user_external_id_len + 1) * sizeof(char));
if (!user_info->user_external_id) {
destroy_user_info(user_info);
return NULL;
}
strcpy(user_info->user_external_id, external_id);
user_info->user_access_token = (char *) KAA_MALLOC((user_info->user_access_token_len + 1) * sizeof(char));
if (!user_info->user_access_token) {
destroy_user_info(user_info);
return NULL;
}
strcpy(user_info->user_access_token, user_access_token);
user_info->user_verifier_token = (char *) KAA_MALLOC((user_info->user_verifier_token_len + 1) * sizeof(char));
if (!user_info->user_verifier_token) {
destroy_user_info(user_info);
return NULL;
}
strcpy(user_info->user_verifier_token, user_verifier_token);
return user_info;
}
/** @deprecated Use kaa_extension_user_init(). */
kaa_error_t kaa_user_manager_create(kaa_user_manager_t **user_manager_p
, kaa_status_t *status
, kaa_channel_manager_t *channel_manager
, kaa_logger_t *logger)
{
KAA_RETURN_IF_NIL2(user_manager_p, status, KAA_ERR_BADPARAM);
*user_manager_p = (kaa_user_manager_t *) KAA_MALLOC(sizeof(kaa_user_manager_t));
KAA_RETURN_IF_NIL((*user_manager_p), KAA_ERR_NOMEM);
(*user_manager_p)->attachment_listeners.on_attached = NULL;
(*user_manager_p)->attachment_listeners.on_detached = NULL;
(*user_manager_p)->attachment_listeners.on_attach_success = NULL;
(*user_manager_p)->attachment_listeners.on_attach_failed = NULL;
(*user_manager_p)->user_info = NULL;
(*user_manager_p)->is_waiting_user_attach_response = false;
(*user_manager_p)->attach_endpoints = kaa_list_create();
(*user_manager_p)->detach_endpoints = kaa_list_create();
(*user_manager_p)->endpoint_request_counter = 0;
(*user_manager_p)->status = status;
(*user_manager_p)->channel_manager = channel_manager;
(*user_manager_p)->logger = logger;
return KAA_ERR_NONE;
}
/** @deprecated Use kaa_extension_user_deinit(). */
void kaa_user_manager_destroy(kaa_user_manager_t *self)
{
if (self) {
kaa_list_destroy(self->attach_endpoints, dtor_endpoint_info);
kaa_list_destroy(self->detach_endpoints, dtor_endpoint_info);
destroy_user_info(self->user_info);
KAA_FREE(self);
}
}
bool kaa_user_manager_is_attached_to_user(kaa_user_manager_t *self)
{
KAA_RETURN_IF_NIL2(self, self->status, false);
return self->status->is_attached;
}
kaa_error_t kaa_user_manager_attach_to_user(kaa_user_manager_t *self
, const char *user_external_id
, const char *access_token
, const char *user_verifier_token)
{
KAA_RETURN_IF_NIL3(self, user_external_id, access_token, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Going to attach to user "
"(external id = \"%s\", access token = \"%s\", verifier token = \"%s\")"
, user_external_id, access_token, user_verifier_token);
if (self->is_waiting_user_attach_response) {
destroy_user_info(self->user_info);
self->user_info = NULL;
self->is_waiting_user_attach_response = false;
}
self->user_info = create_user_info(user_external_id, access_token, user_verifier_token);
if (!self->user_info)
return KAA_ERR_NOMEM;
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, user_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, user_sync_services, 1);
return KAA_ERR_NONE;
}
kaa_error_t kaa_user_manager_attach_endpoint(kaa_user_manager_t *self, const char *endpoint_access_token, kaa_endpoint_status_listener_t *listener)
{
KAA_RETURN_IF_NIL2(self, endpoint_access_token, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Going to attach endpoint by access token "
"(endpoint_access_token = \"%s\")"
, endpoint_access_token);
kaa_endpoint_info_t *info = KAA_CALLOC(1, sizeof(kaa_endpoint_info_t));
KAA_RETURN_IF_NIL(info, KAA_ERR_NOMEM);
info->access_token_length = strlen(endpoint_access_token);
info->access_token = KAA_MALLOC(info->access_token_length);
if (!info->access_token) {
dtor_endpoint_info((void*)info);
return KAA_ERR_NOMEM;
}
memcpy(info->access_token, endpoint_access_token, info->access_token_length);
if (listener)
info->listener = listener;
info->request_id = ++self->endpoint_request_counter;
if (!kaa_list_push_back(self->attach_endpoints, (void*)info)) {
dtor_endpoint_info((void*)info);
return KAA_ERR_NOMEM;
}
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, user_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, user_sync_services, 1);
return KAA_ERR_NONE;
}
kaa_error_t kaa_user_manager_detach_endpoint(kaa_user_manager_t *self, const kaa_endpoint_id_p endpoint_hash_key, kaa_endpoint_status_listener_t *listener)
{
KAA_RETURN_IF_NIL2(self, endpoint_hash_key, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Going to detach endpoint");
kaa_endpoint_info_t *info = KAA_CALLOC(1, sizeof(kaa_endpoint_info_t));
KAA_RETURN_IF_NIL(info, KAA_ERR_NOMEM);
memcpy(info->endpoint_token, endpoint_hash_key, KAA_ENDPOINT_ID_LENGTH);
if (listener)
info->listener = listener;
info->request_id = ++self->endpoint_request_counter;
if (!kaa_list_push_back(self->detach_endpoints, (void*)info)) {
dtor_endpoint_info((void*)info);
return KAA_ERR_NOMEM;
}
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, user_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, user_sync_services, 1);
return KAA_ERR_NONE;
}
#ifdef DEFAULT_USER_VERIFIER_TOKEN
kaa_error_t kaa_user_manager_default_attach_to_user(kaa_user_manager_t *self
, const char *user_external_id
, const char *access_token)
{
KAA_RETURN_IF_NIL3(self, user_external_id, access_token, KAA_ERR_BADPARAM);
return kaa_user_manager_attach_to_user(self, user_external_id, access_token, DEFAULT_USER_VERIFIER_TOKEN);
}
#endif
kaa_error_t kaa_user_manager_set_attachment_listeners(kaa_user_manager_t *self
, const kaa_attachment_status_listeners_t *listeners)
{
KAA_RETURN_IF_NIL(self, KAA_ERR_BADPARAM);
self->attachment_listeners = *listeners;
return KAA_ERR_NONE;
}
static size_t kaa_user_request_get_size_no_header(kaa_user_manager_t *self)
{
size_t expected_size = 0;
if (self->user_info && !self->is_waiting_user_attach_response) {
expected_size += sizeof(uint32_t) // field id + user external ID length + user access token length
+ sizeof(uint32_t); // verifier id length + reserved
expected_size += kaa_aligned_size_get(self->user_info->user_external_id_len);
expected_size += kaa_aligned_size_get(self->user_info->user_access_token_len);
expected_size += kaa_aligned_size_get(self->user_info->user_verifier_token_len);
}
if (kaa_list_get_size(self->attach_endpoints)) {
expected_size += sizeof(uint32_t); // field id + reserved + endpoint attach requests count
kaa_list_node_t *node = kaa_list_begin(self->attach_endpoints);
while (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
expected_size += sizeof(uint32_t) + kaa_aligned_size_get(info->access_token_length); //request id + endpoint access token length
node = kaa_list_next(node);
}
}
if (kaa_list_get_size(self->detach_endpoints)) {
//field id + reserved + endpoint detach requests count
expected_size += sizeof(uint32_t) + kaa_list_get_size(self->detach_endpoints) * (sizeof(uint32_t)/*request id + reserved*/ + KAA_ENDPOINT_ID_LENGTH);
}
return expected_size;
}
kaa_error_t kaa_user_request_get_size(kaa_user_manager_t *self, size_t *expected_size)
{
KAA_RETURN_IF_NIL2(self, expected_size, KAA_ERR_BADPARAM);
*expected_size = KAA_EXTENSION_HEADER_SIZE + kaa_user_request_get_size_no_header(self);
return KAA_ERR_NONE;
}
kaa_error_t kaa_user_request_serialize(kaa_user_manager_t *self, kaa_platform_message_writer_t* writer)
{
KAA_RETURN_IF_NIL2(self, writer, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Going to serialize client user sync");
size_t size = kaa_user_request_get_size_no_header(self);
if (kaa_platform_message_write_extension_header(writer, KAA_EXTENSION_USER, KAA_USER_RECEIVE_UPDATES_FLAG, size)) {
KAA_LOG_ERROR(self->logger, KAA_ERR_WRITE_FAILED, "Failed to write the user extension header");
return KAA_ERR_WRITE_FAILED;
}
if (self->user_info && !self->is_waiting_user_attach_response) {
*(writer->current++) = EXTERNAL_SYSTEM_AUTH_FIELD;
*(writer->current++) = (uint8_t) self->user_info->user_external_id_len;
*((uint16_t *) writer->current) = KAA_HTONS((uint16_t) self->user_info->user_access_token_len);
writer->current += sizeof(uint16_t);
*((uint16_t *) writer->current) = KAA_HTONS((uint16_t) self->user_info->user_verifier_token_len);
writer->current += sizeof(uint32_t); /* verifier token length + reserved */
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Serializing external system authentication parameters: user external id '%s', access token '%s', verifier token '%s'"
, self->user_info->user_external_id, self->user_info->user_access_token, self->user_info->user_verifier_token);
if (self->user_info->user_external_id_len) {
if (kaa_platform_message_write_aligned(writer
, self->user_info->user_external_id
, self->user_info->user_external_id_len))
{
KAA_LOG_ERROR(self->logger, KAA_ERR_WRITE_FAILED, "Failed to write the user external id \"%s\""
, self->user_info->user_external_id);
return KAA_ERR_WRITE_FAILED;
}
}
if (self->user_info->user_access_token_len) {
if (kaa_platform_message_write_aligned(writer
, self->user_info->user_access_token
, self->user_info->user_access_token_len))
{
KAA_LOG_ERROR(self->logger, KAA_ERR_WRITE_FAILED, "Failed to write the user access token \"%s\""
, self->user_info->user_access_token);
return KAA_ERR_WRITE_FAILED;
}
}
if (self->user_info->user_verifier_token_len) {
if (kaa_platform_message_write_aligned(writer
, self->user_info->user_verifier_token
, self->user_info->user_verifier_token_len))
{
KAA_LOG_ERROR(self->logger, KAA_ERR_WRITE_FAILED, "Failed to write the user verifier token \"%s\""
, self->user_info->user_verifier_token);
return KAA_ERR_WRITE_FAILED;
}
}
self->is_waiting_user_attach_response = true;
}
if (kaa_list_get_size(self->attach_endpoints)) {
kaa_list_node_t *node = kaa_list_begin(self->attach_endpoints);
*(writer->current) = EXTERNAL_SYSTEM_ENDPOINT_ATTACH_FIELD;
writer->current += sizeof(uint16_t);
*((uint16_t*)writer->current) = KAA_HTONS((uint16_t)kaa_list_get_size(self->attach_endpoints));
writer->current += sizeof(uint16_t);
while (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (!info->is_waiting_response) {
*((uint16_t*)writer->current) = KAA_HTONS(info->request_id);
writer->current += sizeof(uint16_t);
*((uint16_t*)writer->current) = KAA_HTONS((uint16_t)info->access_token_length);
writer->current += sizeof(uint16_t);
if (kaa_platform_message_write_aligned(writer
, info->access_token
, info->access_token_length))
{
KAA_LOG_ERROR(self->logger, KAA_ERR_WRITE_FAILED, "Failed to write the user Endpoint access token");
return KAA_ERR_WRITE_FAILED;
}
info->is_waiting_response = true;
}
node = kaa_list_next(node);
}
}
if (kaa_list_get_size(self->detach_endpoints)) {
kaa_list_node_t *node = kaa_list_begin(self->detach_endpoints);
*(writer->current) = EXTERNAL_SYSTEM_ENDPOINT_DETACH_FIELD;
writer->current += sizeof(uint16_t);
*((uint16_t*)writer->current) = KAA_HTONS((uint16_t)kaa_list_get_size(self->detach_endpoints));
writer->current += sizeof(uint16_t);
while (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (!info->is_waiting_response) {
*((uint16_t*)writer->current) = KAA_HTONS(info->request_id);
writer->current += sizeof(uint32_t);
memcpy(writer->current, info->endpoint_token, KAA_ENDPOINT_ID_LENGTH);
writer->current += KAA_ENDPOINT_ID_LENGTH;
info->is_waiting_response = true;
}
node = kaa_list_next(node);
}
}
return KAA_ERR_NONE;
}
kaa_error_t kaa_user_handle_server_sync(kaa_user_manager_t *self
, kaa_platform_message_reader_t *reader
, uint16_t extension_options
, size_t extension_length)
{
// Only used for logging
(void)extension_options;
(void)extension_length;
KAA_RETURN_IF_NIL2(self, reader, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received user server sync: options %u, payload size %u", extension_options, extension_length);
size_t remaining_length = extension_length;
while (remaining_length > 0) {
uint32_t field_header = KAA_NTOHL(*(uint32_t *)reader->current);
reader->current += sizeof(uint32_t);
remaining_length -= sizeof(uint32_t);
user_server_sync_field_t field = (field_header >> 24) & 0xFF;
switch (field) {
case USER_ATTACH_RESPONSE_FIELD: {
user_sync_result_t result = (uint8_t) (field_header >> 8) & 0xFF;
destroy_user_info(self->user_info);
self->user_info = NULL;
self->is_waiting_user_attach_response = false;
if (result == USER_RESULT_SUCCESS) {
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Endpoint was successfully attached to user");
kaa_status_set_attached(self->status, true);
if (self->attachment_listeners.on_attach_success)
(self->attachment_listeners.on_attach_success)(self->attachment_listeners.context);
} else {
uint16_t user_verifier_error_code;
if (kaa_platform_message_read(reader, &user_verifier_error_code, sizeof(uint16_t))) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read user verifier error code");
return KAA_ERR_READ_FAILED;
}
user_verifier_error_code = KAA_NTOHS(user_verifier_error_code);
remaining_length -= sizeof(uint16_t);
uint16_t reason_length;
if (kaa_platform_message_read(reader, &reason_length, sizeof(uint16_t))) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read reason length");
return KAA_ERR_READ_FAILED;
}
reason_length = KAA_NTOHS(reason_length);
remaining_length -= sizeof(uint16_t);
if (reason_length) {
char reason[reason_length + 1];
if (kaa_platform_message_read_aligned(reader, reason, reason_length)) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read error reason");
return KAA_ERR_READ_FAILED;
}
reason[reason_length] = '\0';
remaining_length -= kaa_aligned_size_get(reason_length);
KAA_LOG_ERROR(self->logger, KAA_ERR_EVENT_NOT_ATTACHED, "Failed to attach to user: error %d, reason '%s'", user_verifier_error_code, reason);
if (self->attachment_listeners.on_attach_failed) {
(self->attachment_listeners.on_attach_failed)(self->attachment_listeners.context
, (user_verifier_error_code_t)user_verifier_error_code
, reason);
}
} else {
KAA_LOG_ERROR(self->logger, KAA_ERR_EVENT_NOT_ATTACHED, "Failed to attach to user: error %d, reason 'unknown'", user_verifier_error_code);
if (self->attachment_listeners.on_attach_failed) {
(self->attachment_listeners.on_attach_failed)(self->attachment_listeners.context
, (user_verifier_error_code_t)user_verifier_error_code
, NULL);
}
}
}
break;
}
case USER_ATTACH_NOTIFICATION_FIELD: {
uint8_t external_id_length = (field_header >> 16) & 0xFF;
uint16_t access_token_length = (field_header) & 0xFFFF;
if (external_id_length + access_token_length > remaining_length)
return KAA_ERR_INVALID_BUFFER_SIZE;
char external_id[external_id_length + 1];
char access_token[access_token_length + 1];
if (kaa_platform_message_read_aligned(reader, external_id, external_id_length)) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read the external ID (length %u)"
, external_id_length);
return KAA_ERR_READ_FAILED;
}
external_id[external_id_length] = '\0';
remaining_length -= kaa_aligned_size_get(external_id_length);
if (kaa_platform_message_read_aligned(reader, access_token, access_token_length)) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read the access token (length %u)"
, access_token_length);
return KAA_ERR_READ_FAILED;
}
access_token[access_token_length] = '\0';
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received user attach notification: endpoint external id '%s' (length %u), access token '%s' (length %u)"
, external_id, external_id_length, access_token, access_token_length);
remaining_length -= kaa_aligned_size_get(access_token_length);
kaa_status_set_attached(self->status, true);
if (self->attachment_listeners.on_attached)
(self->attachment_listeners.on_attached)(self->attachment_listeners.context
, external_id, access_token);
break;
}
case USER_DETACH_NOTIFICATION_FIELD: {
uint16_t access_token_length = (field_header) & 0xFFFF;
if (access_token_length > remaining_length)
return KAA_ERR_INVALID_BUFFER_SIZE;
char access_token[access_token_length + 1];
if (kaa_platform_message_read_aligned(reader, access_token, access_token_length)) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to read the access token (length %u)"
, access_token_length);
return KAA_ERR_READ_FAILED;
}
access_token[access_token_length] = '\0';
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received user detach notification: endpoint access token '%s' (length %u)"
, access_token, access_token_length);
remaining_length -= kaa_aligned_size_get(access_token_length);
kaa_status_set_attached(self->status, false);
if (self->attachment_listeners.on_detached)
(self->attachment_listeners.on_detached)(self->attachment_listeners.context, access_token);
break;
}
case ENDPOINT_ATTACH_RESPONSES_FIELD: {
uint16_t attach_responses_count = (field_header) & 0xFFFF;
if (sizeof(uint32_t) > remaining_length) {
return KAA_ERR_INVALID_BUFFER_SIZE;
}
for (uint32_t i = 0; i < attach_responses_count; ++i) {
uint8_t result_code = *(reader->current++);
uint8_t options = *(reader->current++);
uint16_t request_id = KAA_NTOHS(*(uint16_t*)reader->current);
reader->current += sizeof(uint16_t);
remaining_length -= sizeof(uint32_t);
if (result_code == USER_RESULT_FAILURE) {
kaa_list_node_t *node = kaa_list_find_next(kaa_list_begin(self->attach_endpoints), match_predicate_endpoint_info, (void*)&request_id);
if (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (info->listener && info->listener->on_attach_failed)
info->listener->on_attach_failed(info->listener->context);
kaa_list_remove_at(self->attach_endpoints, node, dtor_endpoint_info);
}
continue;
}
if (options & USER_SYNC_ENDPOINT_ID_OPTION) {
kaa_endpoint_id endpoint_id;
memcpy(endpoint_id, reader->current, KAA_ENDPOINT_ID_LENGTH);
reader->current += KAA_ENDPOINT_ID_LENGTH;
remaining_length -= KAA_ENDPOINT_ID_LENGTH;
kaa_list_node_t *node = kaa_list_find_next(kaa_list_begin(self->attach_endpoints), match_predicate_endpoint_info, (void*)&request_id);
if (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (info->listener && info->listener->on_attached)
info->listener->on_attached(info->listener->context, endpoint_id);
kaa_list_remove_at(self->attach_endpoints, node, dtor_endpoint_info);
}
}
}
break;
}
case ENDPOINT_DETACH_RESPONSES_FIELD: {
uint16_t detach_responses_count = field_header & 0xFFFF;
if (sizeof(uint32_t) > remaining_length) {
return KAA_ERR_INVALID_BUFFER_SIZE;
}
for (uint32_t i = 0; i < detach_responses_count; ++i) {
uint8_t result_code = *(reader->current++);
reader->current++;
uint16_t request_id = KAA_NTOHS(*(uint16_t*)reader->current);
reader->current += sizeof(uint16_t);
remaining_length -= sizeof(uint32_t);
if (result_code == USER_RESULT_FAILURE) {
kaa_list_node_t *node = kaa_list_find_next(kaa_list_begin(self->detach_endpoints), match_predicate_endpoint_info, (void*)&request_id);
if (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (info->listener && info->listener->on_detach_failed)
info->listener->on_detach_failed(info->listener->context);
kaa_list_remove_at(self->detach_endpoints, node, dtor_endpoint_info);
}
continue;
}
kaa_list_node_t *node = kaa_list_find_next(kaa_list_begin(self->detach_endpoints), match_predicate_endpoint_info, (void*)&request_id);
if (node) {
kaa_endpoint_info_t *info = (kaa_endpoint_info_t*)kaa_list_get_data(node);
if (info->listener && info->listener->on_detached)
info->listener->on_detached(info->listener->context);
kaa_list_remove_at(self->detach_endpoints, node, dtor_endpoint_info);
}
}
break;
}
default:
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Invalid field %u", field);
return KAA_ERR_READ_FAILED;
}
}
return KAA_ERR_NONE;
}
|
790974.c | #include <stdio.h>
int main()
{
int n, S;
printf("Enter the size of the array\n");
scanf("%d", &n);
int arr[n];
printf("Enter the elements of the array.\n");
for (int m = 0; m < n; m++)
{
scanf("%d", &arr[m]);
}
printf("Enter the no of which you want the sum of elements to be equal to:- \n");
scanf("%d", &S);
for (int i = 0; i < n; i++)
{
int sum = 0;
for (int j = i; j < n; j++)
{
sum += arr[j];
if (sum == S)
{
for (int p = i; p <= j; p++)
{
printf("%d ", arr[p]);
}
printf("\n");
break;
}
}
}
return 0;
} |
862818.c |
#include <stdio.h>
#include "internal/cryptlib.h"
#ifndef OPENSSL_NO_WHIRLPOOL
# include <openssl/evp.h>
# include <openssl/objects.h>
# include <openssl/x509.h>
# include <openssl/whrlpool.h>
# include "internal/evp_int.h"
static int init(EVP_MD_CTX *ctx)
{
return WHIRLPOOL_Init(EVP_MD_CTX_md_data(ctx));
}
static int update(EVP_MD_CTX *ctx, const void *data, size_t count)
{
return WHIRLPOOL_Update(EVP_MD_CTX_md_data(ctx), data, count);
}
static int final(EVP_MD_CTX *ctx, unsigned char *md)
{
return WHIRLPOOL_Final(md, EVP_MD_CTX_md_data(ctx));
}
static const EVP_MD whirlpool_md = {
NID_whirlpool,
0,
WHIRLPOOL_DIGEST_LENGTH,
0,
init,
update,
final,
NULL,
NULL,
WHIRLPOOL_BBLOCK / 8,
sizeof(EVP_MD *) + sizeof(WHIRLPOOL_CTX),
};
const EVP_MD *EVP_whirlpool(void)
{
return (&whirlpool_md);
}
#endif
|
257329.c | /**
* Sensortek STK3310/STK3311 Ambient Light and Proximity Sensor
*
* Copyright (c) 2015, Intel Corporation.
*
* This file is subject to the terms and conditions of version 2 of
* the GNU General Public License. See the file COPYING in the main
* directory of this archive for more details.
*
* IIO driver for STK3310/STK3311. 7-bit I2C address: 0x48.
*/
#include <linux/acpi.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/gpio/consumer.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#define STK3310_REG_STATE 0x00
#define STK3310_REG_PSCTRL 0x01
#define STK3310_REG_ALSCTRL 0x02
#define STK3310_REG_INT 0x04
#define STK3310_REG_THDH_PS 0x06
#define STK3310_REG_THDL_PS 0x08
#define STK3310_REG_FLAG 0x10
#define STK3310_REG_PS_DATA_MSB 0x11
#define STK3310_REG_PS_DATA_LSB 0x12
#define STK3310_REG_ALS_DATA_MSB 0x13
#define STK3310_REG_ALS_DATA_LSB 0x14
#define STK3310_REG_ID 0x3E
#define STK3310_MAX_REG 0x80
#define STK3310_STATE_EN_PS BIT(0)
#define STK3310_STATE_EN_ALS BIT(1)
#define STK3310_STATE_STANDBY 0x00
#define STK3310_CHIP_ID_VAL 0x13
#define STK3311_CHIP_ID_VAL 0x1D
#define STK3310_PSINT_EN 0x01
#define STK3310_PS_MAX_VAL 0xFFFF
#define STK3310_DRIVER_NAME "stk3310"
#define STK3310_REGMAP_NAME "stk3310_regmap"
#define STK3310_EVENT "stk3310_event"
#define STK3310_SCALE_AVAILABLE "6.4 1.6 0.4 0.1"
#define STK3310_IT_AVAILABLE \
"0.000185 0.000370 0.000741 0.001480 0.002960 0.005920 0.011840 " \
"0.023680 0.047360 0.094720 0.189440 0.378880 0.757760 1.515520 " \
"3.031040 6.062080"
#define STK3310_REGFIELD(name) \
do { \
data->reg_##name = \
devm_regmap_field_alloc(&client->dev, regmap, \
stk3310_reg_field_##name); \
if (IS_ERR(data->reg_##name)) { \
dev_err(&client->dev, "reg field alloc failed.\n"); \
return PTR_ERR(data->reg_##name); \
} \
} while (0)
static const struct reg_field stk3310_reg_field_state =
REG_FIELD(STK3310_REG_STATE, 0, 2);
static const struct reg_field stk3310_reg_field_als_gain =
REG_FIELD(STK3310_REG_ALSCTRL, 4, 5);
static const struct reg_field stk3310_reg_field_ps_gain =
REG_FIELD(STK3310_REG_PSCTRL, 4, 5);
static const struct reg_field stk3310_reg_field_als_it =
REG_FIELD(STK3310_REG_ALSCTRL, 0, 3);
static const struct reg_field stk3310_reg_field_ps_it =
REG_FIELD(STK3310_REG_PSCTRL, 0, 3);
static const struct reg_field stk3310_reg_field_int_ps =
REG_FIELD(STK3310_REG_INT, 0, 2);
static const struct reg_field stk3310_reg_field_flag_psint =
REG_FIELD(STK3310_REG_FLAG, 4, 4);
static const struct reg_field stk3310_reg_field_flag_nf =
REG_FIELD(STK3310_REG_FLAG, 0, 0);
/* Estimate maximum proximity values with regard to measurement scale. */
static const int stk3310_ps_max[4] = {
STK3310_PS_MAX_VAL / 640,
STK3310_PS_MAX_VAL / 160,
STK3310_PS_MAX_VAL / 40,
STK3310_PS_MAX_VAL / 10
};
static const int stk3310_scale_table[][2] = {
{6, 400000}, {1, 600000}, {0, 400000}, {0, 100000}
};
/* Integration time in seconds, microseconds */
static const int stk3310_it_table[][2] = {
{0, 185}, {0, 370}, {0, 741}, {0, 1480},
{0, 2960}, {0, 5920}, {0, 11840}, {0, 23680},
{0, 47360}, {0, 94720}, {0, 189440}, {0, 378880},
{0, 757760}, {1, 515520}, {3, 31040}, {6, 62080},
};
struct stk3310_data {
struct i2c_client *client;
struct mutex lock;
bool als_enabled;
bool ps_enabled;
u64 timestamp;
struct regmap *regmap;
struct regmap_field *reg_state;
struct regmap_field *reg_als_gain;
struct regmap_field *reg_ps_gain;
struct regmap_field *reg_als_it;
struct regmap_field *reg_ps_it;
struct regmap_field *reg_int_ps;
struct regmap_field *reg_flag_psint;
struct regmap_field *reg_flag_nf;
};
static const struct iio_event_spec stk3310_events[] = {
/* Proximity event */
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_RISING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
/* Out-of-proximity event */
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_FALLING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
};
static const struct iio_chan_spec stk3310_channels[] = {
{
.type = IIO_LIGHT,
.info_mask_separate =
BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_INT_TIME),
},
{
.type = IIO_PROXIMITY,
.info_mask_separate =
BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_INT_TIME),
.event_spec = stk3310_events,
.num_event_specs = ARRAY_SIZE(stk3310_events),
}
};
static IIO_CONST_ATTR(in_illuminance_scale_available, STK3310_SCALE_AVAILABLE);
static IIO_CONST_ATTR(in_proximity_scale_available, STK3310_SCALE_AVAILABLE);
static IIO_CONST_ATTR(in_illuminance_integration_time_available,
STK3310_IT_AVAILABLE);
static IIO_CONST_ATTR(in_proximity_integration_time_available,
STK3310_IT_AVAILABLE);
static struct attribute *stk3310_attributes[] = {
&iio_const_attr_in_illuminance_scale_available.dev_attr.attr,
&iio_const_attr_in_proximity_scale_available.dev_attr.attr,
&iio_const_attr_in_illuminance_integration_time_available.dev_attr.attr,
&iio_const_attr_in_proximity_integration_time_available.dev_attr.attr,
NULL,
};
static const struct attribute_group stk3310_attribute_group = {
.attrs = stk3310_attributes
};
static int stk3310_get_index(const int table[][2], int table_size,
int val, int val2)
{
int i;
for (i = 0; i < table_size; i++) {
if (val == table[i][0] && val2 == table[i][1])
return i;
}
return -EINVAL;
}
static int stk3310_read_event(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
enum iio_event_info info,
int *val, int *val2)
{
u8 reg;
__be16 buf;
int ret;
struct stk3310_data *data = iio_priv(indio_dev);
if (info != IIO_EV_INFO_VALUE)
return -EINVAL;
/* Only proximity interrupts are implemented at the moment. */
if (dir == IIO_EV_DIR_RISING)
reg = STK3310_REG_THDH_PS;
else if (dir == IIO_EV_DIR_FALLING)
reg = STK3310_REG_THDL_PS;
else
return -EINVAL;
mutex_lock(&data->lock);
ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
mutex_unlock(&data->lock);
if (ret < 0) {
dev_err(&data->client->dev, "register read failed\n");
return ret;
}
*val = be16_to_cpu(buf);
return IIO_VAL_INT;
}
static int stk3310_write_event(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
enum iio_event_info info,
int val, int val2)
{
u8 reg;
__be16 buf;
int ret;
unsigned int index;
struct stk3310_data *data = iio_priv(indio_dev);
struct i2c_client *client = data->client;
ret = regmap_field_read(data->reg_ps_gain, &index);
if (ret < 0)
return ret;
if (val < 0 || val > stk3310_ps_max[index])
return -EINVAL;
if (dir == IIO_EV_DIR_RISING)
reg = STK3310_REG_THDH_PS;
else if (dir == IIO_EV_DIR_FALLING)
reg = STK3310_REG_THDL_PS;
else
return -EINVAL;
buf = cpu_to_be16(val);
ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
if (ret < 0)
dev_err(&client->dev, "failed to set PS threshold!\n");
return ret;
}
static int stk3310_read_event_config(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir)
{
unsigned int event_val;
int ret;
struct stk3310_data *data = iio_priv(indio_dev);
ret = regmap_field_read(data->reg_int_ps, &event_val);
if (ret < 0)
return ret;
return event_val;
}
static int stk3310_write_event_config(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
int state)
{
int ret;
struct stk3310_data *data = iio_priv(indio_dev);
struct i2c_client *client = data->client;
if (state < 0 || state > 7)
return -EINVAL;
/* Set INT_PS value */
mutex_lock(&data->lock);
ret = regmap_field_write(data->reg_int_ps, state);
if (ret < 0)
dev_err(&client->dev, "failed to set interrupt mode\n");
mutex_unlock(&data->lock);
return ret;
}
static int stk3310_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
u8 reg;
__be16 buf;
int ret;
unsigned int index;
struct stk3310_data *data = iio_priv(indio_dev);
struct i2c_client *client = data->client;
if (chan->type != IIO_LIGHT && chan->type != IIO_PROXIMITY)
return -EINVAL;
switch (mask) {
case IIO_CHAN_INFO_RAW:
if (chan->type == IIO_LIGHT)
reg = STK3310_REG_ALS_DATA_MSB;
else
reg = STK3310_REG_PS_DATA_MSB;
mutex_lock(&data->lock);
ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
if (ret < 0) {
dev_err(&client->dev, "register read failed\n");
mutex_unlock(&data->lock);
return ret;
}
*val = be16_to_cpu(buf);
mutex_unlock(&data->lock);
return IIO_VAL_INT;
case IIO_CHAN_INFO_INT_TIME:
if (chan->type == IIO_LIGHT)
ret = regmap_field_read(data->reg_als_it, &index);
else
ret = regmap_field_read(data->reg_ps_it, &index);
if (ret < 0)
return ret;
*val = stk3310_it_table[index][0];
*val2 = stk3310_it_table[index][1];
return IIO_VAL_INT_PLUS_MICRO;
case IIO_CHAN_INFO_SCALE:
if (chan->type == IIO_LIGHT)
ret = regmap_field_read(data->reg_als_gain, &index);
else
ret = regmap_field_read(data->reg_ps_gain, &index);
if (ret < 0)
return ret;
*val = stk3310_scale_table[index][0];
*val2 = stk3310_scale_table[index][1];
return IIO_VAL_INT_PLUS_MICRO;
}
return -EINVAL;
}
static int stk3310_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
int ret;
int index;
struct stk3310_data *data = iio_priv(indio_dev);
if (chan->type != IIO_LIGHT && chan->type != IIO_PROXIMITY)
return -EINVAL;
switch (mask) {
case IIO_CHAN_INFO_INT_TIME:
index = stk3310_get_index(stk3310_it_table,
ARRAY_SIZE(stk3310_it_table),
val, val2);
if (index < 0)
return -EINVAL;
mutex_lock(&data->lock);
if (chan->type == IIO_LIGHT)
ret = regmap_field_write(data->reg_als_it, index);
else
ret = regmap_field_write(data->reg_ps_it, index);
if (ret < 0)
dev_err(&data->client->dev,
"sensor configuration failed\n");
mutex_unlock(&data->lock);
return ret;
case IIO_CHAN_INFO_SCALE:
index = stk3310_get_index(stk3310_scale_table,
ARRAY_SIZE(stk3310_scale_table),
val, val2);
if (index < 0)
return -EINVAL;
mutex_lock(&data->lock);
if (chan->type == IIO_LIGHT)
ret = regmap_field_write(data->reg_als_gain, index);
else
ret = regmap_field_write(data->reg_ps_gain, index);
if (ret < 0)
dev_err(&data->client->dev,
"sensor configuration failed\n");
mutex_unlock(&data->lock);
return ret;
}
return -EINVAL;
}
static const struct iio_info stk3310_info = {
.driver_module = THIS_MODULE,
.read_raw = stk3310_read_raw,
.write_raw = stk3310_write_raw,
.attrs = &stk3310_attribute_group,
.read_event_value = stk3310_read_event,
.write_event_value = stk3310_write_event,
.read_event_config = stk3310_read_event_config,
.write_event_config = stk3310_write_event_config,
};
static int stk3310_set_state(struct stk3310_data *data, u8 state)
{
int ret;
struct i2c_client *client = data->client;
/* 3-bit state; 0b100 is not supported. */
if (state > 7 || state == 4)
return -EINVAL;
mutex_lock(&data->lock);
ret = regmap_field_write(data->reg_state, state);
if (ret < 0) {
dev_err(&client->dev, "failed to change sensor state\n");
} else if (state != STK3310_STATE_STANDBY) {
/* Don't reset the 'enabled' flags if we're going in standby */
data->ps_enabled = !!(state & STK3310_STATE_EN_PS);
data->als_enabled = !!(state & STK3310_STATE_EN_ALS);
}
mutex_unlock(&data->lock);
return ret;
}
static int stk3310_init(struct iio_dev *indio_dev)
{
int ret;
int chipid;
u8 state;
struct stk3310_data *data = iio_priv(indio_dev);
struct i2c_client *client = data->client;
ret = regmap_read(data->regmap, STK3310_REG_ID, &chipid);
if (ret < 0)
return ret;
if (chipid != STK3310_CHIP_ID_VAL &&
chipid != STK3311_CHIP_ID_VAL) {
dev_err(&client->dev, "invalid chip id: 0x%x\n", chipid);
return -ENODEV;
}
state = STK3310_STATE_EN_ALS | STK3310_STATE_EN_PS;
ret = stk3310_set_state(data, state);
if (ret < 0) {
dev_err(&client->dev, "failed to enable sensor");
return ret;
}
/* Enable PS interrupts */
ret = regmap_field_write(data->reg_int_ps, STK3310_PSINT_EN);
if (ret < 0)
dev_err(&client->dev, "failed to enable interrupts!\n");
return ret;
}
static bool stk3310_is_volatile_reg(struct device *dev, unsigned int reg)
{
switch (reg) {
case STK3310_REG_ALS_DATA_MSB:
case STK3310_REG_ALS_DATA_LSB:
case STK3310_REG_PS_DATA_LSB:
case STK3310_REG_PS_DATA_MSB:
case STK3310_REG_FLAG:
return true;
default:
return false;
}
}
static struct regmap_config stk3310_regmap_config = {
.name = STK3310_REGMAP_NAME,
.reg_bits = 8,
.val_bits = 8,
.max_register = STK3310_MAX_REG,
.cache_type = REGCACHE_RBTREE,
.volatile_reg = stk3310_is_volatile_reg,
};
static int stk3310_regmap_init(struct stk3310_data *data)
{
struct regmap *regmap;
struct i2c_client *client;
client = data->client;
regmap = devm_regmap_init_i2c(client, &stk3310_regmap_config);
if (IS_ERR(regmap)) {
dev_err(&client->dev, "regmap initialization failed.\n");
return PTR_ERR(regmap);
}
data->regmap = regmap;
STK3310_REGFIELD(state);
STK3310_REGFIELD(als_gain);
STK3310_REGFIELD(ps_gain);
STK3310_REGFIELD(als_it);
STK3310_REGFIELD(ps_it);
STK3310_REGFIELD(int_ps);
STK3310_REGFIELD(flag_psint);
STK3310_REGFIELD(flag_nf);
return 0;
}
static irqreturn_t stk3310_irq_handler(int irq, void *private)
{
struct iio_dev *indio_dev = private;
struct stk3310_data *data = iio_priv(indio_dev);
data->timestamp = iio_get_time_ns();
return IRQ_WAKE_THREAD;
}
static irqreturn_t stk3310_irq_event_handler(int irq, void *private)
{
int ret;
unsigned int dir;
u64 event;
struct iio_dev *indio_dev = private;
struct stk3310_data *data = iio_priv(indio_dev);
/* Read FLAG_NF to figure out what threshold has been met. */
mutex_lock(&data->lock);
ret = regmap_field_read(data->reg_flag_nf, &dir);
if (ret < 0) {
dev_err(&data->client->dev, "register read failed\n");
mutex_unlock(&data->lock);
return ret;
}
event = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1,
IIO_EV_TYPE_THRESH,
(dir ? IIO_EV_DIR_FALLING :
IIO_EV_DIR_RISING));
iio_push_event(indio_dev, event, data->timestamp);
/* Reset the interrupt flag */
ret = regmap_field_write(data->reg_flag_psint, 0);
if (ret < 0)
dev_err(&data->client->dev, "failed to reset interrupts\n");
mutex_unlock(&data->lock);
return IRQ_HANDLED;
}
static int stk3310_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
struct iio_dev *indio_dev;
struct stk3310_data *data;
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
if (!indio_dev) {
dev_err(&client->dev, "iio allocation failed!\n");
return -ENOMEM;
}
data = iio_priv(indio_dev);
data->client = client;
i2c_set_clientdata(client, indio_dev);
mutex_init(&data->lock);
ret = stk3310_regmap_init(data);
if (ret < 0)
return ret;
indio_dev->dev.parent = &client->dev;
indio_dev->info = &stk3310_info;
indio_dev->name = STK3310_DRIVER_NAME;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = stk3310_channels;
indio_dev->num_channels = ARRAY_SIZE(stk3310_channels);
ret = stk3310_init(indio_dev);
if (ret < 0)
return ret;
if (client->irq > 0) {
ret = devm_request_threaded_irq(&client->dev, client->irq,
stk3310_irq_handler,
stk3310_irq_event_handler,
IRQF_TRIGGER_FALLING |
IRQF_ONESHOT,
STK3310_EVENT, indio_dev);
if (ret < 0) {
dev_err(&client->dev, "request irq %d failed\n",
client->irq);
goto err_standby;
}
}
ret = iio_device_register(indio_dev);
if (ret < 0) {
dev_err(&client->dev, "device_register failed\n");
goto err_standby;
}
return 0;
err_standby:
stk3310_set_state(data, STK3310_STATE_STANDBY);
return ret;
}
static int stk3310_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
iio_device_unregister(indio_dev);
return stk3310_set_state(iio_priv(indio_dev), STK3310_STATE_STANDBY);
}
#ifdef CONFIG_PM_SLEEP
static int stk3310_suspend(struct device *dev)
{
struct stk3310_data *data;
data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
return stk3310_set_state(data, STK3310_STATE_STANDBY);
}
static int stk3310_resume(struct device *dev)
{
u8 state = 0;
struct stk3310_data *data;
data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
if (data->ps_enabled)
state |= STK3310_STATE_EN_PS;
if (data->als_enabled)
state |= STK3310_STATE_EN_ALS;
return stk3310_set_state(data, state);
}
static SIMPLE_DEV_PM_OPS(stk3310_pm_ops, stk3310_suspend, stk3310_resume);
#define STK3310_PM_OPS (&stk3310_pm_ops)
#else
#define STK3310_PM_OPS NULL
#endif
static const struct i2c_device_id stk3310_i2c_id[] = {
{"STK3310", 0},
{"STK3311", 0},
{}
};
MODULE_DEVICE_TABLE(i2c, stk3310_i2c_id);
static const struct acpi_device_id stk3310_acpi_id[] = {
{"STK3310", 0},
{"STK3311", 0},
{}
};
MODULE_DEVICE_TABLE(acpi, stk3310_acpi_id);
static struct i2c_driver stk3310_driver = {
.driver = {
.name = "stk3310",
.pm = STK3310_PM_OPS,
.acpi_match_table = ACPI_PTR(stk3310_acpi_id),
},
.probe = stk3310_probe,
.remove = stk3310_remove,
.id_table = stk3310_i2c_id,
};
module_i2c_driver(stk3310_driver);
MODULE_AUTHOR("Tiberiu Breana <[email protected]>");
MODULE_DESCRIPTION("STK3310 Ambient Light and Proximity Sensor driver");
MODULE_LICENSE("GPL v2");
|
558422.c | /*-
* Copyright (c) 1982, 1986, 1988, 1990, 1993
* The Regents of the University of California.
* Copyright (c) 2004 The FreeBSD Foundation
* Copyright (c) 2004-2008 Robert N. M. Watson
* Copyright (c) 2014, Nokia
* Copyright (c) 2014, Enea Software AB
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)uipc_socket.c 8.3 (Berkeley) 4/15/94
*/
/*
* Comments on the socket life cycle:
*
* soalloc() sets of socket layer state for a socket, called only by
* ofp_socreate() and ofp_sonewconn(). Socket layer private.
*
* sodealloc() tears down socket layer state for a socket, called only by
* ofp_sofree() and ofp_sonewconn(). Socket layer private.
*
* pru_attach() associates protocol layer state with an allocated socket;
* called only once, may fail, aborting socket allocation. This is called
* from ofp_socreate() and ofp_sonewconn(). Socket layer private.
*
* pru_detach() disassociates protocol layer state from an attached socket,
* and will be called exactly once for sockets in which pru_attach() has
* been successfully called. If pru_attach() returned an error,
* pru_detach() will not be called. Socket layer private.
*
* pru_abort() and pru_close() notify the protocol layer that the last
* consumer of a socket is starting to tear down the socket, and that the
* protocol should terminate the connection. Historically, pru_abort() also
* detached protocol state from the socket state, but this is no longer the
* case.
*
* ofp_socreate() creates a socket and attaches protocol state. This is a public
* interface that may be used by socket layer consumers to create new
* sockets.
*
* ofp_sonewconn() creates a socket and attaches protocol state. This is a
* public interface that may be used by protocols to create new sockets when
* a new connection is received and will be available for accept() on a
* listen socket.
*
* ofp_soclose() destroys a socket after possibly waiting for it to disconnect.
* This is a public interface that socket consumers should use to close and
* release a socket when done with it.
*
* ofp_soabort() destroys a socket without waiting for it to disconnect (used
* only for incoming connections that are already partially or fully
* connected). This is used internally by the socket layer when clearing
* listen socket queues (due to overflow or close on the listen socket), but
* is also a public interface protocols may use to abort connections in
* their incomplete listen queues should they no longer be required. Sockets
* placed in completed connection listen queues should not be aborted for
* reasons described in the comment above the ofp_soclose() implementation. This
* is not a general purpose close routine, and except in the specific
* circumstances described here, should not be used.
*
* ofp_sofree() will free a socket and its protocol state if all references on
* the socket have been released, and is the public interface to attempt to
* free a socket when a reference is removed. This is a socket layer private
* interface.
*
* NOTE: In addition to ofp_socreate() and ofp_soclose(), which provide a single
* socket reference to the consumer to be managed as required, there are two
* calls to explicitly manage socket references, soref(), and sorele().
* Currently, these are generally required only when transitioning a socket
* from a listen queue to a file descriptor, in order to prevent garbage
* collection of the socket at an untimely moment. For a number of reasons,
* these interfaces are not preferred, and should be avoided.
*
* NOTE: With regard to VNETs the general rule is that callers do not set
* curvnet. Exceptions to this rule include ofp_soabort(), ofp_sodisconnect(),
* ofp_sofree() (and with that sorele(), sotryfree()), as well as ofp_sonewconn()
* and sorflush(), which are usually called from a pre-set VNET context.
* sopoll() currently does not need a VNET context to be set.
*/
#include <string.h>
#include <unistd.h>
#include <stddef.h>
#include <limits.h>
#include "odp.h"
#include "ofpi_errno.h"
#include "ofpi_timer.h"
#include "ofpi_inet.h"
#include "ofpi_in.h"
#include "ofpi_ip.h"
#include "ofpi_ip6.h"
#include "ofpi_udp.h"
#include "ofpi_icmp.h"
#include "ofpi_util.h"
#include "ofpi_socketvar.h"
#include "ofpi_socket.h"
#include "ofpi_in_pcb.h"
#include "ofpi_domain.h"
#include "ofpi_protosw.h"
#include "ofpi_ip6protosw.h"
#include "ofpi_sockstate.h"
#include "ofpi_tcp_var.h"
#include "ofpi_tcp_shm.h"
#include "ofpi_tcp_timer.h"
#include "ofpi_callout.h"
#include "ofpi_log.h"
#define SHM_NAME_SOCKET "OfpSocketShMem"
#define OFP_NUM_SOCKET_POOLS 32
/*
* Shared data
*/
struct ofp_socket_mem {
struct socket socket_list[OFP_NUM_SOCKETS_MAX];
struct socket *free_sockets;
int sockets_allocated, max_sockets_allocated;
int socket_zone;
odp_rwlock_t so_global_mtx;
odp_rwlock_t ofp_accept_mtx;
int somaxconn;
odp_pool_t pool;
struct sleeper {
struct sleeper *next;
void *channel;
const char *wmesg;
int go;
odp_timer_t tmo;
int woke_by_timer;
} *sleep_list;
struct sleeper sleeper_list[OFP_NUM_SOCKETS_MAX];
struct sleeper *free_sleepers;
odp_spinlock_t sleep_lock;
};
/*
* Data per core
*/
//static __thread struct ofp_socket_mem *shm;
static struct ofp_socket_mem *shm;
#if 0
/* For debugging */
void print_open_conns(void);
void ofp_print_long_counters(void);
void ofp_print_sockets(void)
{
int i;
for (i = 0; i < OFP_NUM_SOCKETS_MAX; i++) {
struct socket *so = &shm->socket_list[i];
if (!so->so_proto)
continue;
OFP_INFO("Socket %d: rcv.put=%d rcv.get=%d snd.put=%d snd.get=%d",
so->so_number, so->so_rcv.sb_put, so->so_rcv.sb_get,
so->so_snd.sb_put, so->so_snd.sb_get);
}
struct sleeper *s = shm->sleep_list;
while (s) {
OFP_INFO("Sleeper %s, tmo=%x go=%d timer=%d",
s->wmesg, s->tmo, s->go, s->woke_by_timer);
s = s->next;
}
print_open_conns();
}
struct cli_conn;
void f_sockets(struct cli_conn *conn, const char *s)
{
ofp_print_sockets();
}
#endif
odp_packet_t ofp_packet_alloc(uint32_t len)
{
return odp_packet_alloc(shm->pool, len);
}
odp_rwlock_t *ofp_accept_mtx(void)
{
return &shm->ofp_accept_mtx;
}
void ofp_accept_lock(void)
{
odp_rwlock_write_lock(&shm->ofp_accept_mtx);
}
void ofp_accept_unlock(void)
{
odp_rwlock_write_unlock(&shm->ofp_accept_mtx);
}
static int ofp_socket_alloc_shared_memory(void)
{
shm = ofp_shared_memory_alloc(SHM_NAME_SOCKET, sizeof(*shm));
if (shm == NULL) {
OFP_ERR("ofp_shared_memory_alloc failed");
return -1;
}
return 0;
}
static int ofp_socket_free_shared_memory(void)
{
int rc = 0;
if (ofp_shared_memory_free(SHM_NAME_SOCKET) == -1) {
OFP_ERR("ofp_shared_memory_free failed");
rc = -1;
}
shm = NULL;
return rc;
}
int ofp_socket_lookup_shared_memory(void)
{
shm = ofp_shared_memory_lookup(SHM_NAME_SOCKET);
if (shm == NULL) {
OFP_ERR("ofp_shared_memory_lookup failed");
return -1;
}
return 0;
}
int ofp_socket_init_global(odp_pool_t pool)
{
uint32_t i;
HANDLE_ERROR(ofp_socket_alloc_shared_memory());
memset(shm, 0, sizeof(*shm));
shm->pool = ODP_POOL_INVALID;
for (i = 0; i < OFP_NUM_SOCKETS_MAX; i++) {
shm->socket_list[i].next = (i == OFP_NUM_SOCKETS_MAX - 1) ?
NULL : &(shm->socket_list[i+1]);
shm->socket_list[i].so_number = i + OFP_SOCK_NUM_OFFSET;
}
shm->free_sockets = &(shm->socket_list[0]);
for (i = 0; i < OFP_NUM_SOCKETS_MAX; i++) {
shm->sleeper_list[i].next = (i == OFP_NUM_SOCKETS_MAX - 1) ?
NULL : &(shm->sleeper_list[i+1]);
}
shm->free_sleepers = &(shm->sleeper_list[0]);
shm->somaxconn = SOMAXCONN;
shm->pool = pool;
odp_rwlock_init(&shm->so_global_mtx);
odp_rwlock_init(&shm->ofp_accept_mtx);
odp_spinlock_init(&shm->sleep_lock);
return 0;
}
int ofp_socket_term_global(void)
{
struct sleeper *p, *next;
int rc = 0;
p = shm->sleep_list;
while (p) {
next = p->next;
if (p->tmo != ODP_TIMER_INVALID) {
CHECK_ERROR(ofp_timer_cancel(p->tmo), rc);
p->tmo = ODP_TIMER_INVALID;
}
p->go = 1;
p = next;
}
ofp_inet_term();
CHECK_ERROR(ofp_socket_free_shared_memory(), rc);
return rc;
}
struct socket *ofp_get_sock_by_fd(int fd)
{
return &shm->socket_list[fd - OFP_SOCK_NUM_OFFSET];
}
/*
* Get a socket structure from our zone, and initialize it.
* Allocate socket and PCB at the same time.
*
* soalloc() returns a socket with a ref count of 0.
*/
static struct socket *soalloc(void)
{
#if 1
odp_rwlock_write_lock(&shm->so_global_mtx);
struct socket *so = shm->free_sockets;
if (shm->free_sockets) {
shm->free_sockets = shm->free_sockets->next;
shm->sockets_allocated++;
if (shm->sockets_allocated > shm->max_sockets_allocated)
shm->max_sockets_allocated = shm->sockets_allocated;
}
odp_rwlock_write_unlock(&shm->so_global_mtx);
#else
struct socket *so = ofp_socket_pool_alloc(shm->socket_zone);
#endif
if (so == NULL) {
OFP_ERR("Cannot allocate socket!");
return (NULL);
}
/* clean socket memory */
int number = so->so_number;
memset(so, 0, sizeof(*so));
so->so_number = number;
SOCKBUF_LOCK_INIT(&so->so_snd, "so_snd");
SOCKBUF_LOCK_INIT(&so->so_rcv, "so_rcv");
odp_spinlock_init(&so->so_snd.sb_sx);
odp_spinlock_init(&so->so_rcv.sb_sx);
return (so);
}
/*
* Free the storage associated with a socket at the socket layer, tear down
* locks, labels, etc. All protocol state is assumed already to have been
* torn down (and possibly never set up) by the caller.
*/
static void
sodealloc(struct socket *so)
{
KASSERT(so->so_count == 0, ("sodealloc(): so_count %d", so->so_count));
KASSERT(so->so_pcb == NULL, ("sodealloc(): so_pcb != NULL"));
so->so_proto = 0;
odp_rwlock_write_lock(&shm->so_global_mtx);
so->next = shm->free_sockets;
shm->free_sockets = so;
shm->sockets_allocated--;
odp_rwlock_write_unlock(&shm->so_global_mtx);
}
/*
* ofp_socreate returns a socket with a ref count of 1. The socket should be
* closed with ofp_soclose().
*/
int
ofp_socreate(int dom, struct socket **aso, int type, int proto, struct thread *td)
{
struct protosw *prp;
struct socket *so;
int error;
prp = ofp_pffindproto(dom, proto, type);
if (prp == NULL || prp->pr_usrreqs->pru_attach == NULL ||
prp->pr_usrreqs->pru_attach == ofp_pru_attach_notsupp)
return (OFP_EPROTONOSUPPORT);
if (prp->pr_type == 0)
return (OFP_EPROTONOSUPPORT);
if (prp->pr_type != type)
return (OFP_EPROTOTYPE);
so = soalloc();
if (so == NULL)
return (OFP_ENOBUFS);
OFP_TAILQ_INIT(&so->so_incomp);
OFP_TAILQ_INIT(&so->so_comp);
so->so_type = type;
// HJo: FIX: so->so_cred = crhold(cred);
so->so_cred = &so->so_cred_space;
so->so_fibnum = td->td_proc.p_fibnum;
so->so_proto = prp;
#if 0
knlist_init_mtx(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv));
knlist_init_mtx(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd));
#endif
so->so_count = 1;
error = (*prp->pr_usrreqs->pru_attach)(so, proto, td);
if (error) {
KASSERT(so->so_count == 1, ("ofp_socreate: so_count %d",
so->so_count));
so->so_count = 0;
sodealloc(so);
return (error);
}
*aso = so;
return (0);
}
/*
* When an attempt at a new connection is noted on a socket which accepts
* connections, ofp_sonewconn is called. If the connection is possible (subject
* to space constraints, etc.) then we allocate a new structure, properly
* linked into the data structure of the original socket, and return this.
* Connstatus may be 0, or OFP_SO_ISCONFIRMING, or OFP_SO_ISCONNECTED.
*
* Note: the ref count on the socket is 0 on return.
*/
struct socket *
ofp_sonewconn(struct socket *head, int connstatus)
{
struct socket *so;
int over;
ACCEPT_LOCK();
over = (head->so_qlen > 3 * head->so_qlimit / 2);
ACCEPT_UNLOCK();
if (over)
return (NULL);
so = soalloc();
if (so == NULL)
return (NULL);
if ((head->so_options & OFP_SO_ACCEPTFILTER) != 0)
connstatus = 0;
so->so_head = head;
so->so_type = head->so_type;
so->so_options = head->so_options &~ (OFP_SO_ACCEPTCONN|OFP_SO_PASSIVE);
so->so_linger = head->so_linger;
so->so_state = head->so_state | SS_NOFDREF;
so->so_fibnum = head->so_fibnum;
so->so_proto = head->so_proto;
//HJo so->so_cred = crhold(head->so_cred);
//knlist_init_mtx(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv));
//knlist_init_mtx(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd));
if (ofp_soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat) ||
(*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) {
sodealloc(so);
return (NULL);
}
so->so_rcv.sb_lowat = head->so_rcv.sb_lowat;
so->so_snd.sb_lowat = head->so_snd.sb_lowat;
so->so_rcv.sb_timeo = head->so_rcv.sb_timeo;
so->so_snd.sb_timeo = head->so_snd.sb_timeo;
so->so_rcv.sb_flags |= head->so_rcv.sb_flags & SB_AUTOSIZE;
so->so_snd.sb_flags |= head->so_snd.sb_flags & SB_AUTOSIZE;
so->so_state |= connstatus;
so->so_sigevent = head->so_sigevent;
so->so_rcv.sb_socket = so;
so->so_snd.sb_socket = NULL;
ACCEPT_LOCK();
if (connstatus) {
OFP_TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
so->so_qstate |= SQ_COMP;
head->so_qlen++;
} else {
/*
* Keep removing sockets from the head until there's room for
* us to insert on the tail. In pre-locking revisions, this
* was a simple if(), but as we could be racing with other
* threads and ofp_soabort() requires dropping locks, we must
* loop waiting for the condition to be true.
*/
while (head->so_incqlen > head->so_qlimit) {
struct socket *sp;
sp = OFP_TAILQ_FIRST(&head->so_incomp);
OFP_TAILQ_REMOVE(&head->so_incomp, sp, so_list);
head->so_incqlen--;
sp->so_qstate &= ~SQ_INCOMP;
sp->so_head = NULL;
ACCEPT_UNLOCK();
ofp_soabort(sp);
ACCEPT_LOCK();
}
OFP_TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list);
so->so_qstate |= SQ_INCOMP;
head->so_incqlen++;
}
ACCEPT_UNLOCK();
if (connstatus) {
sorwakeup(head);
ofp_wakeup_one(&head->so_timeo);
}
return (so);
}
int
ofp_sobind(struct socket *so, struct ofp_sockaddr *nam, struct thread *td)
{
int error;
error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, td);
return error;
}
/*
* ofp_solisten() transitions a socket from a non-listening state to a listening
* state, but can also be used to update the listen queue depth on an
* existing listen socket. The protocol will call back into the sockets
* layer using ofp_solisten_proto_check() and ofp_solisten_proto() to check and set
* socket-layer listen state. Call backs are used so that the protocol can
* acquire both protocol and socket layer locks in whatever order is required
* by the protocol.
*
* Protocol implementors are advised to hold the socket lock across the
* socket-layer test and set to avoid races at the socket layer.
*/
int
ofp_solisten(struct socket *so, int backlog, struct thread *td)
{
int error;
error = (*so->so_proto->pr_usrreqs->pru_listen)(so, backlog, td);
return error;
}
int
ofp_solisten_proto_check(struct socket *so)
{
OFP_SOCK_LOCK_ASSERT(so);
if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
SS_ISDISCONNECTING))
return (OFP_EINVAL);
return (0);
}
void
ofp_solisten_proto(struct socket *so, int backlog)
{
OFP_SOCK_LOCK_ASSERT(so);
if (backlog < 0 || backlog > shm->somaxconn)
backlog = shm->somaxconn;
so->so_qlimit = backlog;
so->so_options |= OFP_SO_ACCEPTCONN;
}
static void
sofree_dequeue(struct socket *so)
{
struct socket *head;
head = so->so_head;
if (head != NULL) {
KASSERT((so->so_qstate & SQ_COMP) != 0 ||
(so->so_qstate & SQ_INCOMP) != 0,
("ofp_sofree: so_head != NULL, but neither SQ_COMP nor "
"SQ_INCOMP"));
KASSERT((so->so_qstate & SQ_COMP) == 0 ||
(so->so_qstate & SQ_INCOMP) == 0,
("ofp_sofree: so->so_qstate is SQ_COMP and also SQ_INCOMP"));
OFP_TAILQ_REMOVE(&head->so_incomp, so, so_list);
head->so_incqlen--;
so->so_qstate &= ~SQ_INCOMP;
so->so_head = NULL;
}
KASSERT((so->so_qstate & SQ_COMP) == 0 &&
(so->so_qstate & SQ_INCOMP) == 0,
("ofp_sofree: so_head == NULL, but still SQ_COMP(%d) or SQ_INCOMP(%d)",
so->so_qstate & SQ_COMP, so->so_qstate & SQ_INCOMP));
if (so->so_options & OFP_SO_ACCEPTCONN) {
KASSERT((OFP_TAILQ_EMPTY(&so->so_comp)), ("ofp_sofree: so_comp populated"));
KASSERT((OFP_TAILQ_EMPTY(&so->so_incomp)), ("ofp_sofree: so_comp populated"));
}
}
static void
sofree_dispose(struct socket *so)
{
struct protosw *pr = so->so_proto;
#if 0
if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose != NULL)
(*pr->pr_domain->dom_dispose)(so->so_rcv.sb_mb);
#endif
if (pr->pr_usrreqs->pru_detach != NULL)
(*pr->pr_usrreqs->pru_detach)(so);
/*
* From this point on, we assume that no other references to this
* socket exist anywhere else in the stack. Therefore, no locks need
* to be acquired or held.
*
* We used to do a lot of socket buffer and socket locking here, as
* well as invoke sorflush() and perform wakeups. The direct call to
* dom_dispose() and ofp_sbrelease_internal() are an inlining of what was
* necessary from sorflush().
*
* Notice that the socket buffer and kqueue state are torn down
* before calling pru_detach. This means that protocols shold not
* assume they can perform socket wakeups, etc, in their detach code.
*/
ofp_sbdestroy(&so->so_snd, so);
ofp_sbdestroy(&so->so_rcv, so);
#if 0
seldrain(&so->so_snd.sb_sel);
seldrain(&so->so_rcv.sb_sel);
knlist_destroy(&so->so_rcv.sb_sel.si_note);
knlist_destroy(&so->so_snd.sb_sel.si_note);
#endif
sodealloc(so);
}
static int
sohasrefs(const struct socket *so)
{
return ((so->so_state & SS_NOFDREF) == 0 || so->so_count != 0 ||
(so->so_state & SS_PROTOREF) || (so->so_qstate & SQ_COMP));
}
/*
* Evaluate the reference count and named references on a socket; if no
* references remain, free it. This should be called whenever a reference is
* released, such as in sorele(), but also when named reference flags are
* cleared in socket or protocol code.
*
* ofp_sofree() will free the socket if:
*
* - There are no outstanding file descriptor references or related consumers
* (so_count == 0).
*
* - The socket has been closed by user space, if ever open (SS_NOFDREF).
*
* - The protocol does not have an outstanding strong reference on the socket
* (SS_PROTOREF).
*
* - The socket is not in a completed connection queue, so a process has been
* notified that it is present. If it is removed, the user process may
* block in accept() despite select() saying the socket was ready.
*/
void
ofp_sofree(struct socket *so)
{
ACCEPT_LOCK_ASSERT();
OFP_SOCK_LOCK_ASSERT(so);
if (sohasrefs(so)) {
OFP_SOCK_UNLOCK(so);
ACCEPT_UNLOCK();
return;
}
sofree_dequeue(so);
OFP_SOCK_UNLOCK(so);
ACCEPT_UNLOCK();
sofree_dispose(so);
}
/*
* Close a socket on last file table reference removal. Initiate disconnect
* if connected. Free socket when disconnect complete.
*
* This function will sorele() the socket. Note that ofp_soclose() may be called
* prior to the ref count reaching zero. The actual socket structure will
* not be freed until the ref count reaches zero.
*/
int
ofp_soclose(struct socket *so)
{
int error = 0;
KASSERT(!(so->so_state & SS_NOFDREF), ("ofp_soclose: SS_NOFDREF on enter"));
//funsetown(&so->so_sigio);
if (so->so_state & SS_ISCONNECTED) {
if ((so->so_state & SS_ISDISCONNECTING) == 0) {
error = ofp_sodisconnect(so);
if (error) {
if (error == OFP_ENOTCONN)
error = 0;
goto drop;
}
}
if (so->so_options & OFP_SO_LINGER) {
if ((so->so_state & SS_ISDISCONNECTING) &&
(so->so_state & SS_NBIO))
goto drop;
while (so->so_state & SS_ISCONNECTED) {
/* HJo: was tsleep */
error = ofp_msleep(&so->so_timeo, NULL,
0, "soclos", so->so_linger*1000000);
if (error)
break;
}
}
}
drop:
if (so->so_proto->pr_usrreqs->pru_close != NULL)
(*so->so_proto->pr_usrreqs->pru_close)(so);
if (so->so_options & OFP_SO_ACCEPTCONN) {
struct socket *sp;
ACCEPT_LOCK();
while ((sp = OFP_TAILQ_FIRST(&so->so_incomp)) != NULL) {
OFP_TAILQ_REMOVE(&so->so_incomp, sp, so_list);
so->so_incqlen--;
sp->so_qstate &= ~SQ_INCOMP;
sp->so_head = NULL;
ACCEPT_UNLOCK();
ofp_soabort(sp);
ACCEPT_LOCK();
}
while ((sp = OFP_TAILQ_FIRST(&so->so_comp)) != NULL) {
OFP_TAILQ_REMOVE(&so->so_comp, sp, so_list);
so->so_qlen--;
sp->so_qstate &= ~SQ_COMP;
sp->so_head = NULL;
ACCEPT_UNLOCK();
ofp_soabort(sp);
ACCEPT_LOCK();
}
ACCEPT_UNLOCK();
}
ACCEPT_LOCK();
OFP_SOCK_LOCK(so);
KASSERT((so->so_state & SS_NOFDREF) == 0, ("ofp_soclose: NOFDREF"));
so->so_state |= SS_NOFDREF;
sorele(so);
return (error);
}
void
sorflush(struct socket *so)
{
struct sockbuf *sb = &so->so_rcv;
/*struct protosw *pr = so->so_proto;*/
struct sockbuf asb;
/*
* In order to avoid calling dom_dispose with the socket buffer mutex
* held, and in order to generally avoid holding the lock for a long
* time, we make a copy of the socket buffer and clear the original
* (except locks, state). The new socket buffer copy won't have
* initialized locks so we can only call routines that won't use or
* assert those locks.
*
* Dislodge threads currently blocked in receive and wait to acquire
* a lock against other simultaneous readers before clearing the
* socket buffer. Don't let our acquire be interrupted by a signal
* despite any existing socket disposition on interruptable waiting.
*/
ofp_socantrcvmore(so);
(void) ofp_sblock(sb, SBL_WAIT | SBL_NOINTR);
/*
* Invalidate/clear most of the sockbuf structure, but leave selinfo
* and mutex data unchanged.
*/
SOCKBUF_LOCK(sb);
bzero(&asb, offsetof(struct sockbuf, sb_startzero));
bcopy(&sb->sb_startzero, &asb.sb_startzero,
sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
bzero(&sb->sb_startzero,
sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
SOCKBUF_UNLOCK(sb);
ofp_sbunlock(sb);
/*
* Dispose of special rights and flush the socket buffer. Don't call
* any unsafe routines (that rely on locks being initialized) on asb.
*/
/*if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose != NULL)
(*pr->pr_domain->dom_dispose)(asb.sb_mb);*/
ofp_sbrelease_internal(&asb, so);
}
int
ofp_soshutdown(struct socket *so, int how)
{
struct protosw *pr = so->so_proto;
int error;
if (!(how == OFP_SHUT_RD || how == OFP_SHUT_WR || how == OFP_SHUT_RDWR))
return (OFP_EINVAL);
if (pr->pr_usrreqs->pru_flush != NULL) {
(*pr->pr_usrreqs->pru_flush)(so, how);
}
if (how != OFP_SHUT_WR)
sorflush(so);
if (how != OFP_SHUT_RD) {
error = (*pr->pr_usrreqs->pru_shutdown)(so);
return (error);
}
return (0);
}
/*
* ofp_soabort() is used to abruptly tear down a connection, such as when a
* resource limit is reached (listen queue depth exceeded), or if a listen
* socket is closed while there are sockets waiting to be accepted.
*
* This interface is tricky, because it is called on an unreferenced socket,
* and must be called only by a thread that has actually removed the socket
* from the listen queue it was on, or races with other threads are risked.
*
* This interface will call into the protocol code, so must not be called
* with any socket locks held. Protocols do call it while holding their own
* recursible protocol mutexes, but this is something that should be subject
* to review in the future.
*/
void
ofp_soabort(struct socket *so)
{
/*
* In as much as is possible, assert that no references to this
* socket are held. This is not quite the same as asserting that the
* current thread is responsible for arranging for no references, but
* is as close as we can get for now.
*/
KASSERT(so->so_count == 0, ("ofp_soabort: so_count"));
KASSERT((so->so_state & SS_PROTOREF) == 0, ("ofp_soabort: SS_PROTOREF"));
KASSERT(so->so_state & SS_NOFDREF, ("ofp_soabort: !SS_NOFDREF"));
KASSERT((so->so_state & SQ_COMP) == 0, ("ofp_soabort: SQ_COMP"));
KASSERT((so->so_state & SQ_INCOMP) == 0, ("ofp_soabort: SQ_INCOMP"));
if (so->so_proto->pr_usrreqs->pru_abort != NULL)
(*so->so_proto->pr_usrreqs->pru_abort)(so);
ACCEPT_LOCK();
OFP_SOCK_LOCK(so);
ofp_sofree(so);
}
int
ofp_soaccept(struct socket *so, struct ofp_sockaddr **nam)
{
int error;
OFP_SOCK_LOCK(so);
KASSERT((so->so_state & SS_NOFDREF) != 0, ("ofp_soaccept: !NOFDREF"));
so->so_state &= ~SS_NOFDREF;
OFP_SOCK_UNLOCK(so);
error = (*so->so_proto->pr_usrreqs->pru_accept)(so, nam);
return (error);
}
int
ofp_soconnect(struct socket *so, struct ofp_sockaddr *nam, struct thread *td)
{
int error;
if (so->so_options & OFP_SO_ACCEPTCONN)
return (OFP_EOPNOTSUPP);
/*
* If protocol is connection-based, can only connect once.
* Otherwise, if connected, try to disconnect first. This allows
* user to disconnect by connecting to, e.g., a null address.
*/
if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) &&
((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
(error = ofp_sodisconnect(so)))) {
error = OFP_EISCONN;
} else {
/*
* Prevent accumulated error from previous connection from
* biting us.
*/
so->so_error = 0;
error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, td);
}
return (error);
}
int
ofp_sodisconnect(struct socket *so)
{
int error;
if ((so->so_state & SS_ISCONNECTED) == 0)
return (OFP_ENOTCONN);
if (so->so_state & SS_ISDISCONNECTING)
return (OFP_EALREADY);
error = (*so->so_proto->pr_usrreqs->pru_disconnect)(so);
return (error);
}
#define SBLOCKWAIT(f) (((f) & OFP_MSG_DONTWAIT) ? 0 : SBL_WAIT)
int
ofp_sosend_dgram(struct socket *so, struct ofp_sockaddr *addr, struct uio *uio,
odp_packet_t top, odp_packet_t control, int flags, struct thread *td)
{
long space = 0;
ofp_ssize_t resid;
int clen = 0, error, dontroute;
const uint8_t *data;
//size_t len;
KASSERT(so->so_type == OFP_SOCK_DGRAM, ("sodgram_send: !OFP_SOCK_DGRAM"));
KASSERT(so->so_proto->pr_flags & PR_ATOMIC,
("sodgram_send: !PR_ATOMIC"));
if (uio != NULL) {
data = uio->uio_iov->iov_base;
resid = uio->uio_iov->iov_len;
} else {
data = odp_packet_data(top);
resid = odp_packet_len(top);
}
dontroute =
(flags & OFP_MSG_DONTROUTE) && (so->so_options & OFP_SO_DONTROUTE) == 0;
/* HJo
if (td != NULL)
td->td_ru.ru_msgsnd++;
*/
if (control != ODP_PACKET_INVALID)
clen = odp_packet_len(control);
SOCKBUF_LOCK(&so->so_snd);
if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_EPIPE;
goto out;
}
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
SOCKBUF_UNLOCK(&so->so_snd);
goto out;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
/*
* `sendto' and `sendmsg' is allowed on a connection-based
* socket if it supports implied connect. Return OFP_ENOTCONN if
* not connected and no address is supplied.
*/
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
if ((so->so_state & SS_ISCONFIRMING) == 0 &&
!(resid == 0 && clen != 0)) {
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_ENOTCONN;
goto out;
}
} else if (addr == NULL) {
if (so->so_proto->pr_flags & PR_CONNREQUIRED)
error = OFP_ENOTCONN;
else
error = OFP_EDESTADDRREQ;
SOCKBUF_UNLOCK(&so->so_snd);
goto out;
}
}
SOCKBUF_UNLOCK(&so->so_snd);
if (uio != NULL) {
uint8_t *p;
error = OFP_ENOBUFS;
top = ofp_packet_alloc(resid);
if (top == ODP_PACKET_INVALID)
goto out;
odp_packet_user_ptr_set(top, NULL);
error = 0;
p = odp_packet_data(top);
memcpy(p, data, resid);
/*Bogdan: ToDo chain of buffers for multiple uio_iov*/
}
resid = 0;
KASSERT(resid == 0, ("ofp_sosend_dgram: resid != 0"));
/*
* XXXRW: Frobbing OFP_SO_DONTROUTE here is even worse without ofp_sblock
* than with.
*/
if (dontroute) {
OFP_SOCK_LOCK(so);
so->so_options |= OFP_SO_DONTROUTE;
OFP_SOCK_UNLOCK(so);
}
/*
* XXX all the SBS_CANTSENDMORE checks previously done could be out
* of date. We could have recieved a reset packet in an interrupt or
* maybe we slept while doing page faults in uiomove() etc. We could
* probably recheck again inside the locking protection here, but
* there are probably other places that this also happens. We must
* rethink this.
*/
error = (*so->so_proto->pr_usrreqs->pru_send)(so,
(flags & OFP_MSG_OOB) ? PRUS_OOB :
/*
* If the user set OFP_MSG_EOF, the protocol understands this flag and
* nothing left to send then use OFP_PRU_SEND_EOF instead of OFP_PRU_SEND.
*/
((flags & OFP_MSG_EOF) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) &&
(resid <= 0)) ?
PRUS_EOF :
/* If there is more to send set PRUS_MORETOCOME */
(resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
top, addr, control, td);
if (dontroute) {
OFP_SOCK_LOCK(so);
so->so_options &= ~OFP_SO_DONTROUTE;
OFP_SOCK_UNLOCK(so);
}
clen = 0;
control = ODP_PACKET_INVALID;
top = ODP_PACKET_INVALID;
out:
if (top != ODP_PACKET_INVALID)
odp_packet_free(top);
if (control != ODP_PACKET_INVALID)
odp_packet_free(control);
return (error);
}
/*
* Send on a socket. If send must go all at once and message is larger than
* send buffering, then hard error. Lock against other senders. If must go
* all at once and not enough room now, then inform user that this would
* block and do nothing. Otherwise, if nonblocking, send as much as
* possible. The data to be sent is described by "uio" if nonzero, otherwise
* by the mbuf chain "top" (which must be null if uio is not). Data provided
* in mbuf chain must be small enough to send all at once.
*
* Returns nonzero on error, timeout or signal; callers must check for short
* counts if OFP_EINTR/OFP_ERESTART are returned. Data and control buffers are freed
* on return.
*/
int
ofp_sosend_generic(struct socket *so, struct ofp_sockaddr *addr, struct uio *uio,
odp_packet_t top, odp_packet_t control, int flags, struct thread *td)
{
long space;
ofp_ssize_t resid;
int clen = 0, error, dontroute;
int atomic = sosendallatonce(so) || top;
if (uio != NULL)
resid = uio->uio_resid;
else
resid = odp_packet_len(top);
/*
* In theory resid should be unsigned. However, space must be
* signed, as it might be less than 0 if we over-committed, and we
* must use a signed comparison of space and resid. On the other
* hand, a negative resid causes us to loop sending 0-length
* segments to the protocol.
*
* Also check to make sure that OFP_MSG_EOR isn't used on OFP_SOCK_STREAM
* type sockets since that's an error.
*/
if (resid < 0 || (so->so_type == OFP_SOCK_STREAM && (flags & OFP_MSG_EOR))) {
error = OFP_EINVAL;
goto out;
}
dontroute =
(flags & OFP_MSG_DONTROUTE) && (so->so_options & OFP_SO_DONTROUTE) == 0 &&
(so->so_proto->pr_flags & PR_ATOMIC);
/* HJo
if (td != NULL)
td->td_ru.ru_msgsnd++;
*/
if (control != ODP_PACKET_INVALID)
clen = odp_packet_len(control);
error = ofp_sblock(&so->so_snd, SBLOCKWAIT(flags));
if (error)
goto out;
restart:
do {
SOCKBUF_LOCK(&so->so_snd);
if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_EPIPE;
goto release;
}
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
SOCKBUF_UNLOCK(&so->so_snd);
goto release;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
/*
* `sendto' and `sendmsg' is allowed on a connection-
* based socket if it supports implied connect.
* Return OFP_ENOTCONN if not connected and no address is
* supplied.
*/
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
if ((so->so_state & SS_ISCONFIRMING) == 0 &&
!(resid == 0 && clen != 0)) {
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_ENOTCONN;
goto release;
}
} else if (addr == NULL) {
SOCKBUF_UNLOCK(&so->so_snd);
if (so->so_proto->pr_flags & PR_CONNREQUIRED)
error = OFP_ENOTCONN;
else
error = OFP_EDESTADDRREQ;
goto release;
}
}
space = sbspace(&so->so_snd);
if (flags & OFP_MSG_OOB)
space += 1024;
if ((atomic && resid > so->so_snd.sb_hiwat) ||
clen > (int)so->so_snd.sb_hiwat) {
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_EMSGSIZE;
goto release;
}
if (space < resid + clen &&
(atomic || space < so->so_snd.sb_lowat || space < clen)) {
if ((so->so_state & SS_NBIO) || (flags & OFP_MSG_NBIO)) {
if (so->so_upcallprep.soup_send) {
so->so_upcallprep.soup_send(so,
so->so_upcallprep.soup_send_arg,
resid);
}
SOCKBUF_UNLOCK(&so->so_snd);
error = OFP_EWOULDBLOCK;
goto release;
}
error = ofp_sbwait(&so->so_snd);
SOCKBUF_UNLOCK(&so->so_snd);
if (error)
goto release;
goto restart;
}
SOCKBUF_UNLOCK(&so->so_snd);
space -= clen;
do {
int cancopy = 0;
if (uio == NULL) {
resid = 0;
/* HJo: FIX
if (flags & OFP_MSG_EOR)
odp_packet_flags(top) |= M_EOR;
*/
} else {
top = odp_packet_alloc(shm->pool, 1);
error = OFP_ENOBUFS;
if (top == ODP_PACKET_INVALID)
goto release;
cancopy = resid;
if (cancopy > SHM_PKT_POOL_BUFFER_SIZE)
cancopy = SHM_PKT_POOL_BUFFER_SIZE;
if (cancopy > space)
cancopy = space;
odp_packet_reset(top, cancopy);
odp_packet_user_ptr_set(top, NULL);
uint8_t *p = odp_packet_data(top);
memcpy(p, uio->uio_iov->iov_base, cancopy);
uio->uio_iov->iov_base = cancopy +
(uint8_t *)uio->uio_iov->iov_base;
space -= cancopy;
resid -= cancopy;
}
if (dontroute) {
OFP_SOCK_LOCK(so);
so->so_options |= OFP_SO_DONTROUTE;
OFP_SOCK_UNLOCK(so);
}
/*
* XXX all the SBS_CANTSENDMORE checks previously
* done could be out of date. We could have recieved
* a reset packet in an interrupt or maybe we slept
* while doing page faults in uiomove() etc. We
* could probably recheck again inside the locking
* protection here, but there are probably other
* places that this also happens. We must rethink
* this.
*/
error = (*so->so_proto->pr_usrreqs->pru_send)(so,
(flags & OFP_MSG_OOB) ? PRUS_OOB :
/*
* If the user set OFP_MSG_EOF, the protocol understands
* this flag and nothing left to send then use
* OFP_PRU_SEND_EOF instead of OFP_PRU_SEND.
*/
((flags & OFP_MSG_EOF) &&
(so->so_proto->pr_flags & PR_IMPLOPCL) &&
(resid <= 0)) ?
PRUS_EOF :
/* If there is more to send set PRUS_MORETOCOME. */
(resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
top, addr, control, td);
if (dontroute) {
OFP_SOCK_LOCK(so);
so->so_options &= ~OFP_SO_DONTROUTE;
OFP_SOCK_UNLOCK(so);
}
clen = 0;
control = ODP_PACKET_INVALID;
top = ODP_PACKET_INVALID;
if (error)
goto release;
uio->uio_resid -= cancopy;
} while (resid && space > 0);
} while (resid);
release:
ofp_sbunlock(&so->so_snd);
out:
if (top != ODP_PACKET_INVALID)
odp_packet_free(top);
if (control != ODP_PACKET_INVALID)
odp_packet_free(control);
return (error);
}
int
ofp_sosend(struct socket *so, struct ofp_sockaddr *addr, struct uio *uio,
odp_packet_t top, odp_packet_t control, int flags, struct thread *td)
{
int error;
if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
if (!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING))) {
OFP_ERR("OFP_ENOTCONN: state = %x", so->so_state);
return OFP_ENOTCONN;
} else if (addr)
return OFP_EISCONN;
}
error = so->so_proto->pr_usrreqs->pru_sosend(so, addr, uio, top,
control, flags, td);
return (error);
}
/*
* Implement receive operations on a socket. We depend on the way that
* records are added to the sockbuf by sbappend. In particular, each record
* (mbufs linked through m_next) must begin with an address if the protocol
* so specifies, followed by an optional mbuf or mbufs containing ancillary
* data, and then zero or more mbufs of data. In order to allow parallelism
* between network receive and copying to user space, as well as avoid
* sleeping with a mutex held, we release the socket buffer mutex during the
* user space copy. Although the sockbuf is locked, new data may still be
* appended, and thus we must maintain consistency of the sockbuf during that
* time.
*
* The caller may receive the data as a single mbuf chain by supplying an
* mbuf **mp0 for use in returning the chain. The uio is then used only for
* the count in uio_resid.
*/
int
ofp_soreceive_generic(struct socket *so, struct ofp_sockaddr **psa, struct uio *uio,
odp_packet_t *mp0, odp_packet_t *controlp, int *flagsp)
{
odp_packet_t m, *mp;
int flags, error, offset;
ofp_ssize_t len;
struct protosw *pr = so->so_proto;
int moff/*, type = 0, last_m_flags, hole_break = 0*/;
ofp_ssize_t orig_resid = uio->uio_resid;
uint32_t uio_off;
mp = mp0;
if (psa != NULL)
*psa = NULL;
if (controlp != NULL)
*controlp = ODP_PACKET_INVALID;
if (flagsp != NULL) {
/* hole_break = *flagsp & OFP_MSG_HOLE_BREAK;*/
*flagsp &= ~OFP_MSG_HOLE_BREAK;
flags = *flagsp &~ OFP_MSG_EOR;
} else
flags = 0;
/* HJo: FIX
if (flags & OFP_MSG_OOB)
return (soreceive_rcvoob(so, uio, flags));
*/
if (mp != NULL)
*mp = ODP_PACKET_INVALID;
if ((pr->pr_flags & PR_WANTRCVD) && (so->so_state & SS_ISCONFIRMING)
&& uio->uio_resid) {
(*pr->pr_usrreqs->pru_rcvd)(so, 0);
}
error = ofp_sblock(&so->so_rcv, SBLOCKWAIT(flags));
if (error)
return (error);
restart:
SOCKBUF_LOCK(&so->so_rcv);
m = ofp_sockbuf_get_first(&so->so_rcv);
/*
* If we have less data than requested, block awaiting more (subject
* to any timeout) if:
* 1. the current count is less than the low water mark, or
* 2. OFP_MSG_WAITALL is set, and it is possible to do the entire
* receive operation at once if we block (resid <= hiwat).
* 3. OFP_MSG_DONTWAIT is not set
* If OFP_MSG_WAITALL is set but resid is larger than the receive buffer,
* we have to do the receive in sections, and thus risk returning a
* short count if a timeout or signal occurs after we start.
*/
if (m == ODP_PACKET_INVALID ||
(((flags & OFP_MSG_DONTWAIT) == 0 &&
so->so_rcv.sb_cc < uio->uio_resid) &&
((int)so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
((flags & OFP_MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
(pr->pr_flags & PR_ATOMIC) == 0)) {
KASSERT(m != ODP_PACKET_INVALID || !so->so_rcv.sb_cc,
("receive: so->so_rcv.sb_cc == %u",
so->so_rcv.sb_cc));
if (so->so_error) {
if (m != ODP_PACKET_INVALID)
goto dontblock;
error = so->so_error;
if ((flags & OFP_MSG_PEEK) == 0)
so->so_error = 0;
SOCKBUF_UNLOCK(&so->so_rcv);
goto release;
}
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
if (m == ODP_PACKET_INVALID) {
SOCKBUF_UNLOCK(&so->so_rcv);
goto release;
} else
goto dontblock;
}
/* HJo: FIX:
for (; m != NULL; m = m->m_next)
if (m->m_type == MT_OOBDATA || (odp_packet_flags(m) & M_EOR)) {
m = so->so_rcv.sb_mb;
goto dontblock;
}
*/
if (m != ODP_PACKET_INVALID)
goto dontblock;
if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
SOCKBUF_UNLOCK(&so->so_rcv);
error = OFP_ENOTCONN;
goto release;
}
if (uio->uio_resid == 0) {
SOCKBUF_UNLOCK(&so->so_rcv);
goto release;
}
if ((so->so_state & SS_NBIO) ||
(flags & (OFP_MSG_DONTWAIT|OFP_MSG_NBIO))) {
if (so->so_upcallprep.soup_receive != NULL) {
so->so_upcallprep.soup_receive(so,
so->so_upcallprep.soup_receive_arg,
orig_resid - uio->uio_resid, uio->uio_resid);
}
SOCKBUF_UNLOCK(&so->so_rcv);
error = OFP_EWOULDBLOCK;
goto release;
}
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
error = ofp_sbwait(&so->so_rcv);
SOCKBUF_UNLOCK(&so->so_rcv);
if (error)
goto release;
goto restart;
}
dontblock:
/*
* From this point onward, we maintain 'nextrecord' as a cache of the
* pointer to the next record in the socket buffer. We must keep the
* various socket buffer pointers and local stack versions of the
* pointers in sync, pushing out modifications before dropping the
* socket buffer mutex, and re-reading them when picking it up.
*
* Otherwise, we will race with the network stack appending new data
* or records onto the socket buffer by using inconsistent/stale
* versions of the field, possibly resulting in socket buffer
* corruption.
*
* By holding the high-level ofp_sblock(), we prevent simultaneous
* readers from pulling off the front of the socket buffer.
*/
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
/* HJo
if (uio->uio_td)
uio->uio_td->td_ru.ru_msgrcv++;
KASSERT(m == so->so_rcv.sb_mb, ("ofp_soreceive: m != so->so_rcv.sb_mb"));
*/
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
if (pr->pr_flags & PR_ADDR) {
/* HJo
KASSERT(m->m_type == MT_SONAME,
("m->m_type == %d", m->m_type));
*/
orig_resid = 0;
/* HJo: FIX
if (psa != NULL)
*psa = sodupsockaddr((struct ofp_sockaddr *)odp_packet_data(m),
M_NOWAIT);
*/
if (flags & OFP_MSG_PEEK) {
/* HJo m = m->m_next; */
} else {
/* HJo
sbfree(&so->so_rcv, m);
odp_packet_free(m);
m = ofp_sockbuf_remove_first(&so->so_rcv);
*/
/* sockbuf_pushsync(&so->so_rcv, nextrecord);*/
}
}
#if 0 /* HJo: FIX */
/*
* Process one or more MT_CONTROL mbufs present before any data mbufs
* in the first mbuf chain on the socket buffer. If OFP_MSG_PEEK, we
* just copy the data; if !OFP_MSG_PEEK, we call into the protocol to
* perform externalization (or freeing if controlp == NULL).
*/
if (m != NULL && m->m_type == MT_CONTROL) {
odp_packet_t cm = NULL, *cmn;
odp_packet_t *cme = &cm;
do {
if (flags & OFP_MSG_PEEK) {
if (controlp != NULL) {
*controlp = m_copy(m, 0, odp_packet_get_len(m));
controlp = &(*controlp)->m_next;
}
m = m->m_next;
} else {
sbfree(&so->so_rcv, m);
so->so_rcv.sb_mb = m->m_next;
m->m_next = NULL;
*cme = m;
cme = &(*cme)->m_next;
m = so->so_rcv.sb_mb;
}
} while (m != NULL && m->m_type == MT_CONTROL);
/*
if ((flags & OFP_MSG_PEEK) == 0)
sockbuf_pushsync(&so->so_rcv, nextrecord);
*/
while (cm != NULL) {
cmn = cm->m_next;
cm->m_next = NULL;
if (pr->pr_domain->dom_externalize != NULL) {
SOCKBUF_UNLOCK(&so->so_rcv);
VNET_SO_ASSERT(so);
error = (*pr->pr_domain->dom_externalize)
(cm, controlp);
SOCKBUF_LOCK(&so->so_rcv);
} else if (controlp != NULL)
*controlp = cm;
else
odp_packet_free(cm));
if (controlp != NULL) {
orig_resid = 0;
while (*controlp != NULL)
controlp = &(*controlp)->m_next;
}
cm = cmn;
}
/*
if (m != NULL)
nextrecord = so->so_rcv.sb_mb->m_nextpkt;
else
nextrecord = so->so_rcv.sb_mb;
*/
orig_resid = 0;
}
if (m != NULL) {
if ((flags & OFP_MSG_PEEK) == 0) {
/*
KASSERT(m->m_nextpkt == nextrecord,
("ofp_soreceive: post-control, nextrecord !sync"));
if (nextrecord == NULL) {
KASSERT(so->so_rcv.sb_mb == m,
("ofp_soreceive: post-control, sb_mb!=m"));
KASSERT(so->so_rcv.sb_lastrecord == m,
("ofp_soreceive: post-control, lastrecord!=m"));
}
*/
}
type = m->m_type;
if (type == MT_OOBDATA)
flags |= OFP_MSG_OOB;
last_m_flags = odp_packet_flags(m);
if (hole_break && (odp_packet_flags(m) & M_HOLE))
flags |= OFP_MSG_HOLE_BREAK;
} else {
if ((flags & OFP_MSG_PEEK) == 0) {
/*
KASSERT(so->so_rcv.sb_mb == nextrecord,
("ofp_soreceive: sb_mb != nextrecord"));
if (so->so_rcv.sb_mb == NULL) {
KASSERT(so->so_rcv.sb_lastrecord == NULL,
("ofp_soreceive: sb_lastercord != NULL"));
}
*/
}
}
#endif /* HJo */
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
/*
* Now continue to read any data mbufs off of the head of the socket
* buffer until the read request is satisfied. Note that 'type' is
* used to store the type of any mbuf reads that have happened so far
* such that ofp_soreceive() can stop reading if the type changes, which
* causes ofp_soreceive() to return only one of regular data and inline
* out-of-band data in a single socket receive operation.
*/
moff = 0;
offset = 0;
uio_off = 0;
while (m != ODP_PACKET_INVALID && uio->uio_resid > 0 && error == 0) {
/*
* If the type of mbuf has changed since the last mbuf
* examined ('type'), end the receive operation.
*/
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
/* HJo: FIX
if (hole_break &&
((odp_packet_flags(m) ^ last_m_flags) & M_HOLE))
break;
last_m_flags = odp_packet_flags(m);
if (m->m_type == MT_OOBDATA) {
if (type != MT_OOBDATA)
break;
} else if (type == MT_OOBDATA)
break;
else
KASSERT(m->m_type == MT_DATA,
("m->m_type == %d", m->m_type));
*/
so->so_rcv.sb_state &= ~SBS_RCVATMARK;
len = uio->uio_resid;
if (so->so_oobmark && len > (int)(so->so_oobmark - offset))
len = so->so_oobmark - offset;
if (len > odp_packet_len(m) - moff)
len = odp_packet_len(m) - moff;
/*
* If mp is set, just pass back the mbufs. Otherwise copy
* them out via the uio, then free. Sockbuf must be
* consistent here (points to current mbuf, it points to next
* record) when we drop priority; we must note any additions
* to the sockbuf when we block interrupts again.
*/
if (mp == NULL) {
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
SOCKBUF_UNLOCK(&so->so_rcv);
if (!odp_packet_copy_to_mem(m, moff, len, (void*)
((uintptr_t)uio->uio_iov->iov_base +
uio_off))) {
uio_off += len;
uio->uio_resid -= len;
}
SOCKBUF_LOCK(&so->so_rcv);
if (error) {
/*
* The MT_SONAME mbuf has already been removed
* from the record, so it is necessary to
* remove the data mbufs, if any, to preserve
* the invariant in the case of PR_ADDR that
* requires MT_SONAME mbufs at the head of
* each record.
*/
if (m != ODP_PACKET_INVALID &&
(pr->pr_flags & PR_ATOMIC) &&
((flags & OFP_MSG_PEEK) == 0))
(void)ofp_sbdroprecord_locked(&so->so_rcv);
SOCKBUF_UNLOCK(&so->so_rcv);
goto release;
}
} else
uio->uio_resid -= len;
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (len == odp_packet_len(m) - moff) {
/* HJo
if (odp_packet_flags(m) & M_EOR)
flags |= OFP_MSG_EOR;
*/
if (flags & OFP_MSG_PEEK) {
/* HJo m = m->m_next; */
moff = 0;
} else {
/* HJo nextrecord = m->m_nextpkt; */
sbfree(&so->so_rcv, m);
if (mp != NULL) {
*mp = m;
/* HJo
mp = &m->m_next;
so->so_rcv.sb_mb = m = m->m_next;
*mp = NULL;
*/
} else {
ofp_sockbuf_remove_first(&so->so_rcv);
ofp_sockbuf_packet_free(m);
m = ofp_sockbuf_get_first(&so->so_rcv);
}
/*
sockbuf_pushsync(&so->so_rcv, nextrecord);
*/
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
}
} else {
if (flags & OFP_MSG_PEEK)
moff += len;
else {
if (mp != NULL) {
int copy_flag;
#define M_WAIT 1
#define M_DONTWAIT 2
if (flags & OFP_MSG_DONTWAIT)
copy_flag = M_DONTWAIT;
else
copy_flag = M_WAIT;
if (copy_flag == M_WAIT)
SOCKBUF_UNLOCK(&so->so_rcv);
*mp = odp_packet_copy(m, shm->pool);
if (copy_flag == M_WAIT)
SOCKBUF_LOCK(&so->so_rcv);
if (*mp == ODP_PACKET_INVALID) {
/*
* m_copym() couldn't
* allocate an mbuf. Adjust
* uio_resid back (it was
* adjusted down by len
* bytes, which we didn't end
* up "copying" over).
*/
uio->uio_resid += len;
break;
}
}
/* HJo
if ((odp_packet_flags(m) & M_HOLE) == 0)
m->m_data += len;
odp_packet_get_len(m) -= len;
*/
odp_packet_pull_head(m, len);
so->so_rcv.sb_cc -= len;
}
}
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (so->so_oobmark) {
if ((flags & OFP_MSG_PEEK) == 0) {
so->so_oobmark -= len;
if (so->so_oobmark == 0) {
so->so_rcv.sb_state |= SBS_RCVATMARK;
break;
}
} else {
offset += len;
if (offset == (int)so->so_oobmark)
break;
}
}
if (flags & OFP_MSG_EOR)
break;
/*
* If the OFP_MSG_WAITALL flag is set (for non-atomic socket), we
* must not quit until "uio->uio_resid == 0" or an error
* termination. If a signal/timeout occurs, return with a
* short count but without error. Keep sockbuf locked
* against other readers.
*/
while ((flags & OFP_MSG_WAITALL) && m == ODP_PACKET_INVALID &&
uio->uio_resid > 0 &&
!sosendallatonce(so) /* && nextrecord == NULL*/) {
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (so->so_error || (so->so_rcv.sb_state & SBS_CANTRCVMORE))
break;
/*
* Notify the protocol that some data has been
* drained before blocking.
*/
if (pr->pr_flags & PR_WANTRCVD) {
SOCKBUF_UNLOCK(&so->so_rcv);
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
SOCKBUF_LOCK(&so->so_rcv);
}
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
/*
* We could receive some data while was notifying
* the protocol. Skip blocking in this case.
*/
if (so->so_rcv.sb_mb == NULL) {
error = ofp_sbwait(&so->so_rcv);
if (error) {
SOCKBUF_UNLOCK(&so->so_rcv);
goto release;
}
}
m = ofp_sockbuf_get_first(&so->so_rcv);
}
}
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (m != ODP_PACKET_INVALID && (pr->pr_flags & PR_ATOMIC)) {
flags |= OFP_MSG_TRUNC;
if ((flags & OFP_MSG_PEEK) == 0)
(void) ofp_sbdroprecord_locked(&so->so_rcv);
}
if ((flags & OFP_MSG_PEEK) == 0) {
if (m == ODP_PACKET_INVALID) {
/*
* First part is an inline SB_EMPTY_FIXUP(). Second
* part makes sure sb_lastrecord is up-to-date if
* there is still data in the socket buffer.
*/
if (uio->uio_resid > 0 && orig_resid != uio->uio_resid
&& !sosendallatonce(so) /* && nextrecord == NULL */) {
if (so->so_upcallprep.soup_receive != NULL) {
so->so_upcallprep.soup_receive(so,
so->so_upcallprep.soup_receive_arg,
orig_resid - uio->uio_resid, uio->uio_resid);
}
}
}
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
/*
* If ofp_soreceive() is being done from the socket callback,
* then don't need to generate ACK to peer to update window,
* since ACK will be generated on return to TCP.
*/
if (!(flags & OFP_MSG_SOCALLBCK) &&
(pr->pr_flags & PR_WANTRCVD)) {
SOCKBUF_UNLOCK(&so->so_rcv);
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
SOCKBUF_LOCK(&so->so_rcv);
}
}
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
if (orig_resid == uio->uio_resid && orig_resid &&
(flags & OFP_MSG_EOR) == 0 && (so->so_rcv.sb_state & SBS_CANTRCVMORE) == 0) {
SOCKBUF_UNLOCK(&so->so_rcv);
goto restart;
}
SOCKBUF_UNLOCK(&so->so_rcv);
if (flagsp != NULL)
*flagsp |= flags;
release:
ofp_sbunlock(&so->so_rcv);
return (error);
}
/*
* Optimized version of ofp_soreceive() for simple datagram cases from userspace.
* Unlike in the stream case, we're able to drop a datagram if copyout()
* fails, and because we handle datagrams atomically, we don't need to use a
* sleep lock to prevent I/O interlacing.
*/
int
ofp_soreceive_dgram(struct socket *so, struct ofp_sockaddr **psa, struct uio *uio,
odp_packet_t *mp0, odp_packet_t *controlp, int *flagsp)
{
int flags, error;
size_t len;
struct protosw *pr = so->so_proto;
(void)mp0;
/* HJo: Originally psa will be allocated. We want it set beforehand.
if (psa != NULL)
*psa = NULL;
*/
if (controlp != NULL)
*controlp = ODP_PACKET_INVALID;
if (flagsp != NULL)
flags = *flagsp &~ OFP_MSG_EOR;
else
flags = 0;
/*
* For any complicated cases, fall back to the full
* ofp_soreceive_generic().
*/
#if 0
if (mp0 != NULL || (flags & OFP_MSG_PEEK) || (flags & OFP_MSG_OOB))
return (ofp_soreceive_generic(so, psa, uio, mp0, controlp,
flagsp));
#endif
/*
* Enforce restrictions on use.
*/
KASSERT((pr->pr_flags & PR_WANTRCVD) == 0,
("ofp_soreceive_dgram: wantrcvd"));
KASSERT(pr->pr_flags & PR_ATOMIC, ("ofp_soreceive_dgram: !atomic"));
KASSERT((so->so_rcv.sb_state & SBS_RCVATMARK) == 0,
("ofp_soreceive_dgram: SBS_RCVATMARK"));
KASSERT((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0,
("ofp_soreceive_dgram: P_CONNREQUIRED"));
/*
* Loop blocking while waiting for a datagram.
*/
SOCKBUF_LOCK(&so->so_rcv);
while (so->so_rcv.sb_put == so->so_rcv.sb_get) {
KASSERT(so->so_rcv.sb_cc == 0,
("ofp_soreceive_dgram: sb_mb NULL but sb_cc %u",
so->so_rcv.sb_cc));
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
SOCKBUF_UNLOCK(&so->so_rcv);
return (error);
}
if ((so->so_rcv.sb_state & SBS_CANTRCVMORE) ||
uio->uio_resid == 0) {
SOCKBUF_UNLOCK(&so->so_rcv);
return (0);
}
if ((so->so_state & SS_NBIO) ||
(flags & (OFP_MSG_DONTWAIT|OFP_MSG_NBIO))) {
SOCKBUF_UNLOCK(&so->so_rcv);
return (OFP_EWOULDBLOCK);
}
SBLASTRECORDCHK(&so->so_rcv);
SBLASTMBUFCHK(&so->so_rcv);
error = ofp_sbwait(&so->so_rcv);
if (error) {
SOCKBUF_UNLOCK(&so->so_rcv);
return (error);
}
}
SOCKBUF_LOCK_ASSERT(&so->so_rcv);
odp_packet_t pkt = so->so_rcv.sb_mb[so->so_rcv.sb_get];
sbfree(&so->so_rcv, pkt);
if (++so->so_rcv.sb_get >= SOCKBUF_LEN)
so->so_rcv.sb_get = 0;
SOCKBUF_UNLOCK(&so->so_rcv);
struct ofp_udphdr *uh = (struct ofp_udphdr *)odp_packet_l4_ptr(pkt, NULL);
if (!uh) {
OFP_ERR("UDP HDR == NULL!");
return 0;
}
uint8_t *data = (uint8_t *)(uh + 1);
len = odp_be_to_cpu_16(uh->uh_ulen) - sizeof(*uh);
if (len > uio->uio_iov->iov_len) {
len = uio->uio_iov->iov_len;
flags |= OFP_MSG_TRUNC;
}
memcpy(uio->uio_iov->iov_base, data, len);
if (psa && *psa) {
if (pr->pr_flags & PR_ADDR) {
/* address is save on L2 & L3 */
struct ofp_sockaddr *sa =
(struct ofp_sockaddr *)odp_packet_l2_ptr(pkt, NULL);
memcpy(*psa, sa, sa->sa_len);
} else
(*psa)->sa_len = 0;
}
odp_packet_free(pkt);
uio->uio_resid -= len;
if (flagsp != NULL)
*flagsp |= flags;
return (0);
}
int
ofp_soreceive(struct socket *so, struct ofp_sockaddr **psa, struct uio *uio,
odp_packet_t *mp0, odp_packet_t *controlp, int *flagsp)
{
int error;
if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
if (!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)))
return OFP_ENOTCONN;
}
error = (so->so_proto->pr_usrreqs->pru_soreceive(so, psa, uio, mp0,
controlp, flagsp));
return (error);
}
int
ofp_sooptcopyin(struct sockopt *sopt, void *buf, size_t len, size_t minlen)
{
size_t valsize;
/*
* If the user gives us more than we wanted, we ignore it, but if we
* don't get the minimum length the caller wants, we return OFP_EINVAL.
* On success, sopt->sopt_valsize is set to however much we actually
* retrieved.
*/
if ((valsize = sopt->sopt_valsize) < minlen)
return OFP_EINVAL;
if (valsize > len)
sopt->sopt_valsize = valsize = len;
bcopy(sopt->sopt_val, buf, valsize);
return (0);
}
int
ofp_sosetopt(struct socket *so, struct sockopt *sopt)
{
int error, optval = 0;
struct ofp_linger l;
struct ofp_timeval tv;
uint64_t val;
uint32_t val32;
error = 0;
if (sopt->sopt_level != OFP_SOL_SOCKET) {
if (so->so_proto->pr_ctloutput != NULL) {
error = (*so->so_proto->pr_ctloutput)(so, sopt);
return (error);
}
error = OFP_ENOPROTOOPT;
} else {
switch (sopt->sopt_name) {
case OFP_SO_ACCEPTFILTER:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_LINGER:
error = ofp_sooptcopyin(sopt, &l, sizeof l, sizeof l);
if (error)
goto bad;
OFP_SOCK_LOCK(so);
so->so_linger = l.l_linger;
if (l.l_onoff)
so->so_options |= OFP_SO_LINGER;
else
so->so_options &= ~OFP_SO_LINGER;
OFP_SOCK_UNLOCK(so);
break;
case OFP_SO_DEBUG:
case OFP_SO_KEEPALIVE:
case OFP_SO_DONTROUTE:
case OFP_SO_USELOOPBACK:
case OFP_SO_BROADCAST:
case OFP_SO_REUSEADDR:
case OFP_SO_REUSEPORT:
case OFP_SO_OOBINLINE:
case OFP_SO_TIMESTAMP:
case OFP_SO_BINTIME:
case OFP_SO_NOSIGPIPE:
case OFP_SO_NO_DDP:
case OFP_SO_NO_OFFLOAD:
error = ofp_sooptcopyin(sopt, &optval, sizeof optval,
sizeof optval);
if (error)
goto bad;
OFP_SOCK_LOCK(so);
if (optval)
so->so_options |= sopt->sopt_name;
else
so->so_options &= ~sopt->sopt_name;
OFP_SOCK_UNLOCK(so);
break;
case OFP_SO_SETFIB:
error = ofp_sooptcopyin(sopt, &optval, sizeof optval,
sizeof optval);
if (optval < 0 || optval >= 4096 /* HJo rt_numfibs*/) {
error = OFP_EINVAL;
goto bad;
}
if (((so->so_proto->pr_domain->dom_family == OFP_PF_INET) ||
(so->so_proto->pr_domain->dom_family == OFP_PF_INET6))) {
so->so_fibnum = optval;
/* Note: ignore error */
if (so->so_proto->pr_ctloutput)
(*so->so_proto->pr_ctloutput)(so, sopt);
} else {
so->so_fibnum = 0;
}
break;
case OFP_SO_ALTFIB:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_USER_COOKIE:
error = ofp_sooptcopyin(sopt, &val32, sizeof val32,
sizeof val32);
if (error)
goto bad;
so->so_user_cookie = val32;
break;
case OFP_SO_L2INFO:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_PASSIVE:
case OFP_SO_PROMISC:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_SNDBUF:
case OFP_SO_RCVBUF:
case OFP_SO_SNDLOWAT:
case OFP_SO_RCVLOWAT:
error = ofp_sooptcopyin(sopt, &optval, sizeof optval,
sizeof optval);
if (error)
goto bad;
/*
* Values < 1 make no sense for any of these options,
* so disallow them.
*/
if (optval < 1) {
error = OFP_EINVAL;
goto bad;
}
switch (sopt->sopt_name) {
case OFP_SO_SNDBUF:
case OFP_SO_RCVBUF:
if (ofp_sbreserve(sopt->sopt_name == OFP_SO_SNDBUF ?
&so->so_snd : &so->so_rcv, (uint64_t)optval,
so, NULL) == 0) {
error = OFP_ENOBUFS;
goto bad;
}
(sopt->sopt_name == OFP_SO_SNDBUF ? &so->so_snd :
&so->so_rcv)->sb_flags &= ~SB_AUTOSIZE;
break;
/*
* Make sure the low-water is never greater than the
* high-water.
*/
case OFP_SO_SNDLOWAT:
SOCKBUF_LOCK(&so->so_snd);
so->so_snd.sb_lowat =
(optval > (int)so->so_snd.sb_hiwat) ?
(int)so->so_snd.sb_hiwat : optval;
SOCKBUF_UNLOCK(&so->so_snd);
break;
case OFP_SO_RCVLOWAT:
SOCKBUF_LOCK(&so->so_rcv);
so->so_rcv.sb_lowat =
(optval > (int)so->so_rcv.sb_hiwat) ?
(int)so->so_rcv.sb_hiwat : optval;
SOCKBUF_UNLOCK(&so->so_rcv);
break;
}
break;
case OFP_SO_SNDTIMEO:
case OFP_SO_RCVTIMEO:
error = ofp_sooptcopyin(sopt, &tv, sizeof tv,
sizeof tv);
if (error)
goto bad;
/* assert(hz > 0); */
if (tv.tv_sec > (int32_t)(INT_MAX / hz) ||
tv.tv_usec >= 1000000) {
error = OFP_EDOM;
goto bad;
}
/* assert(tick > 0); */
/* assert(ULONG_MAX - INT_MAX >= 1000000); */
#define tick (1000000/HZ)
val = (uint64_t)(tv.tv_sec * hz) + tv.tv_usec / tick;
if (val > INT_MAX) {
error = OFP_EDOM;
goto bad;
}
if (val == 0 && tv.tv_usec != 0)
val = 1;
switch (sopt->sopt_name) {
case OFP_SO_SNDTIMEO:
so->so_snd.sb_timeo = val;
break;
case OFP_SO_RCVTIMEO:
so->so_rcv.sb_timeo = val;
break;
}
break;
case OFP_SO_LABEL:
error = OFP_EOPNOTSUPP;
break;
default:
error = OFP_ENOPROTOOPT;
break;
}
if (error == 0 && so->so_proto->pr_ctloutput != NULL)
(void)(*so->so_proto->pr_ctloutput)(so, sopt);
}
bad:
return (error);
}
int
ofp_sooptcopyout(struct sockopt *sopt, const void *buf, size_t len)
{
int error;
size_t valsize;
error = 0;
/*
* Documented get behavior is that we always return a value, possibly
* truncated to fit in the user's buffer. Traditional behavior is
* that we always tell the user precisely how much we copied, rather
* than something useful like the total amount we had available for
* her. Note that this interface is not idempotent; the entire
* answer must generated ahead of time.
*/
valsize = min(len, sopt->sopt_valsize);
sopt->sopt_valsize = valsize;
if (sopt->sopt_val != NULL) {
bcopy(buf, sopt->sopt_val, valsize);
}
return (error);
}
int
ofp_sogetopt(struct socket *so, struct sockopt *sopt)
{
int error, optval;
struct ofp_linger l;
struct timeval tv;
error = 0;
if (sopt->sopt_level != OFP_SOL_SOCKET) {
if (so->so_proto->pr_ctloutput != NULL)
error = (*so->so_proto->pr_ctloutput)(so, sopt);
else
error = OFP_ENOPROTOOPT;
return (error);
} else {
switch (sopt->sopt_name) {
case OFP_SO_ACCEPTFILTER:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_LINGER:
OFP_SOCK_LOCK(so);
l.l_onoff = so->so_options & OFP_SO_LINGER;
l.l_linger = so->so_linger;
OFP_SOCK_UNLOCK(so);
error = ofp_sooptcopyout(sopt, &l, sizeof l);
break;
case OFP_SO_USELOOPBACK:
case OFP_SO_DONTROUTE:
case OFP_SO_DEBUG:
case OFP_SO_KEEPALIVE:
case OFP_SO_REUSEADDR:
case OFP_SO_REUSEPORT:
case OFP_SO_BROADCAST:
case OFP_SO_OOBINLINE:
case OFP_SO_ACCEPTCONN:
case OFP_SO_TIMESTAMP:
case OFP_SO_BINTIME:
case OFP_SO_NOSIGPIPE:
optval = so->so_options & sopt->sopt_name;
integer:
error = ofp_sooptcopyout(sopt, &optval, sizeof optval);
break;
case OFP_SO_TYPE:
optval = so->so_type;
goto integer;
case OFP_SO_PROTOCOL:
optval = so->so_proto->pr_protocol;
goto integer;
case OFP_SO_ERROR:
OFP_SOCK_LOCK(so);
optval = so->so_error;
so->so_error = 0;
OFP_SOCK_UNLOCK(so);
goto integer;
case OFP_SO_L2INFO:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_SNDBUF:
optval = so->so_snd.sb_hiwat;
goto integer;
case OFP_SO_RCVBUF:
optval = so->so_rcv.sb_hiwat;
goto integer;
case OFP_SO_SNDLOWAT:
optval = so->so_snd.sb_lowat;
goto integer;
case OFP_SO_RCVLOWAT:
optval = so->so_rcv.sb_lowat;
goto integer;
case OFP_SO_SNDTIMEO:
case OFP_SO_RCVTIMEO:
optval = (sopt->sopt_name == OFP_SO_SNDTIMEO ?
so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
tv.tv_sec = optval / hz;
tv.tv_usec = (optval % hz) * tick;
error = ofp_sooptcopyout(sopt, &tv, sizeof tv);
break;
case OFP_SO_LABEL:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_PEERLABEL:
error = OFP_EOPNOTSUPP;
break;
case OFP_SO_LISTENQLIMIT:
optval = so->so_qlimit;
goto integer;
case OFP_SO_LISTENQLEN:
optval = so->so_qlen;
goto integer;
case OFP_SO_LISTENINCQLEN:
optval = so->so_incqlen;
goto integer;
default:
error = OFP_ENOPROTOOPT;
break;
}
}
return (error);
}
/*
* These functions are used by protocols to notify the socket layer (and its
* consumers) of state changes in the sockets driven by protocol-side events.
*/
/*
* Procedures to manipulate state flags of socket and do appropriate wakeups.
*
* Normal sequence from the active (originating) side is that
* ofp_soisconnecting() is called during processing of connect() call, resulting
* in an eventual call to ofp_soisconnected() if/when the connection is
* established. When the connection is torn down ofp_soisdisconnecting() is
* called during processing of disconnect() call, and ofp_soisdisconnected() is
* called when the connection to the peer is totally severed. The semantics
* of these routines are such that connectionless protocols can call
* ofp_soisconnected() and ofp_soisdisconnected() only, bypassing the in-progress
* calls when setting up a ``connection'' takes no time.
*
* From the passive side, a socket is created with two queues of sockets:
* so_incomp for connections in progress and so_comp for connections already
* made and awaiting user acceptance. As a protocol is preparing incoming
* connections, it creates a socket structure queued on so_incomp by calling
* ofp_sonewconn(). When the connection is established, ofp_soisconnected() is
* called, and transfers the socket structure to so_comp, making it available
* to accept().
*
* If a socket is closed with sockets on either so_incomp or so_comp, these
* sockets are dropped.
*
* If higher-level protocols are implemented in the kernel, the wakeups done
* here will sometimes cause software-interrupt process scheduling.
*/
void
ofp_soisconnecting(struct socket *so)
{
OFP_SOCK_LOCK(so);
so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
so->so_state |= SS_ISCONNECTING;
OFP_SOCK_UNLOCK(so);
}
void
ofp_soisconnected(struct socket *so)
{
struct socket *head;
ACCEPT_LOCK();
OFP_SOCK_LOCK(so);
so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
so->so_state |= SS_ISCONNECTED;
head = so->so_head;
if (head != NULL && (so->so_qstate & SQ_INCOMP)) {
if ((so->so_options & OFP_SO_ACCEPTFILTER) == 0) {
OFP_SOCK_UNLOCK(so);
OFP_TAILQ_REMOVE(&head->so_incomp, so, so_list);
head->so_incqlen--;
so->so_qstate &= ~SQ_INCOMP;
OFP_TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
head->so_qlen++;
so->so_qstate |= SQ_COMP;
ACCEPT_UNLOCK();
ofp_send_sock_event(head, so, OFP_EVENT_ACCEPT);
sorwakeup(head);
ofp_wakeup_one(&head->so_timeo);
} else {
ACCEPT_UNLOCK();
ofp_soupcall_set(so, OFP_SO_RCV,
head->so_accf->so_accept_filter->accf_callback,
head->so_accf->so_accept_filter_arg);
so->so_options &= ~OFP_SO_ACCEPTFILTER;
/* HJo: FIX
ret = head->so_accf->so_accept_filter->accf_callback(so,
head->so_accf->so_accept_filter_arg, M_DONTWAIT);
if (ret == SU_ISCONNECTED)
ofp_soupcall_clear(so, OFP_SO_RCV);
*/
OFP_SOCK_UNLOCK(so);
/* HJo
if (ret == SU_ISCONNECTED)
goto restart;
*/
}
return;
}
OFP_SOCK_UNLOCK(so);
ACCEPT_UNLOCK();
ofp_wakeup(&so->so_timeo);
sorwakeup(so);
sowwakeup(so);
}
void
ofp_soisdisconnecting(struct socket *so)
{
/*
* Note: This code assumes that OFP_SOCK_LOCK(so) and
* SOCKBUF_LOCK(&so->so_rcv) are the same.
*/
/* Socket handled by event and already locked? */
if (!(so->so_state & SS_EVENT))
SOCKBUF_LOCK(&so->so_rcv);
so->so_state &= ~SS_ISCONNECTING;
so->so_state |= SS_ISDISCONNECTING;
so->so_rcv.sb_state |= SBS_CANTRCVMORE;
sorwakeup_locked(so);
SOCKBUF_LOCK(&so->so_snd);
so->so_snd.sb_state |= SBS_CANTSENDMORE;
sowwakeup_locked(so);
ofp_wakeup(&so->so_timeo);
}
void
ofp_soisdisconnected(struct socket *so)
{
/*
* Note: This code assumes that OFP_SOCK_LOCK(so) and
* SOCKBUF_LOCK(&so->so_rcv) are the same.
*/
SOCKBUF_LOCK(&so->so_rcv);
so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
so->so_state |= SS_ISDISCONNECTED;
so->so_rcv.sb_state |= SBS_CANTRCVMORE;
sorwakeup_locked(so);
SOCKBUF_LOCK(&so->so_snd);
so->so_snd.sb_state |= SBS_CANTSENDMORE;
ofp_sbdrop_locked(&so->so_snd, so->so_snd.sb_cc);
sowwakeup_locked(so);
ofp_wakeup(&so->so_timeo);
}
/*
* Register per-socket buffer upcalls.
*/
void
ofp_soupcall_set(struct socket *so, int which,
int (*func)(struct socket *, void *, int), void *arg)
{
struct sockbuf *sb = NULL;
switch (which) {
case OFP_SO_RCV:
sb = &so->so_rcv;
break;
case OFP_SO_SND:
sb = &so->so_snd;
break;
default:
panic("ofp_soupcall_set: bad which");
}
SOCKBUF_LOCK_ASSERT(sb);
#if 0
/* XXX: accf_http actually wants to do this on purpose. */
KASSERT(sb->sb_upcall == NULL, ("ofp_soupcall_set: overwriting upcall"));
#endif
sb->sb_upcall = func;
sb->sb_upcallarg = arg;
sb->sb_flags |= SB_UPCALL;
}
void
ofp_soupcall_clear(struct socket *so, int which)
{
struct sockbuf *sb = NULL;
switch (which) {
case OFP_SO_RCV:
sb = &so->so_rcv;
break;
case OFP_SO_SND:
sb = &so->so_snd;
break;
default:
panic("ofp_soupcall_clear: bad which");
}
SOCKBUF_LOCK_ASSERT(sb);
KASSERT(sb->sb_upcall != NULL, ("ofp_soupcall_clear: no upcall to clear"));
sb->sb_upcall = NULL;
sb->sb_upcallarg = NULL;
sb->sb_flags &= ~SB_UPCALL;
}
/*
* ofp_sohasoutofband(): protocol notifies socket layer of the arrival of new
* out-of-band data, which will then notify socket consumers.
*/
void
ofp_sohasoutofband(struct socket *so)
{
(void)so;
/* HJo: No sig
if (so->so_sigio != NULL)
pgsigio(&so->so_sigio, SIGURG, 0);
*/
/* HJo: FIX
selwakeuppri(&so->so_rcv.sb_sel, PSOCK);
*/
ofp_wakeup(&so->so_rcv.sb_sel);
}
/* Emulation for BSD ofp_wakeup */
static int _ofp_wakeup(void *channel, int one, int tmo);
struct voidarg {
void *p;
};
static void
sleep_timeout(void *arg)
{
struct voidarg *arg1 = arg;
_ofp_wakeup(arg1->p, 1, 1);
}
int
ofp_msleep(void *channel, odp_rwlock_t *mtx, int priority, const char *wmesg,
uint32_t timeout)
{
struct sleeper *sleepy;
struct voidarg arg;
int ret;
(void)mtx;
(void)priority;
odp_spinlock_lock(&shm->sleep_lock);
if (!shm->free_sleepers) {
odp_spinlock_unlock(&shm->sleep_lock);
OFP_ERR("Out of sleepers");
return OFP_ENOMEM;
}
sleepy = shm->free_sleepers;
shm->free_sleepers = sleepy->next;
sleepy->next = shm->sleep_list;
sleepy->channel = channel;
sleepy->wmesg = wmesg;
sleepy->go = 0;
sleepy->woke_by_timer = 0;
sleepy->tmo = ODP_TIMER_INVALID;
shm->sleep_list = sleepy;
if (timeout) {
arg.p = channel;
sleepy->tmo = ofp_timer_start(timeout, sleep_timeout, &arg, sizeof(arg));
}
odp_spinlock_unlock(&shm->sleep_lock);
while (sleepy->go == 0) {
if (mtx) {
odp_rwlock_write_unlock(mtx);
}
sched_yield();
if (mtx) {
odp_rwlock_write_lock(mtx);
}
}
odp_spinlock_lock(&shm->sleep_lock);
if (sleepy->tmo != ODP_TIMER_INVALID)
ofp_timer_cancel(sleepy->tmo);
ret = sleepy->woke_by_timer ? OFP_EWOULDBLOCK : 0;
sleepy->next = shm->free_sleepers;
shm->free_sleepers = sleepy;
odp_spinlock_unlock(&shm->sleep_lock);
return ret;
}
static int
_ofp_wakeup(void *channel, int one, int tmo)
{
struct sleeper *p, *prev = NULL, *next;
odp_spinlock_lock(&shm->sleep_lock);
p = shm->sleep_list;
while (p) {
next = p->next;
if (channel == p->channel) {
if (prev)
prev->next = p->next;
else
shm->sleep_list = p->next;
if (tmo) {
p->tmo = ODP_TIMER_INVALID;
p->woke_by_timer = 1;
}
p->go = 1;
if (one)
break;
} else
prev = p;
p = next;
}
odp_spinlock_unlock(&shm->sleep_lock);
return -1;
}
int
ofp_wakeup_one(void *channel)
{
/* wake up selects */
if (channel)
_ofp_wakeup(NULL, 0, 0);
return _ofp_wakeup(channel, 1, 0);
}
int
ofp_wakeup(void *channel)
{
/* wake up selects */
if (channel)
_ofp_wakeup(NULL, 0, 0);
return _ofp_wakeup(channel, 0, 0);
}
int
ofp_pru_accept_notsupp(struct socket *so, struct ofp_sockaddr **nam)
{
(void)so;
(void)nam;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_attach_notsupp(struct socket *so, int proto, struct thread *td)
{
(void)so;
(void)proto;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_bind_notsupp(struct socket *so, struct ofp_sockaddr *nam, struct thread *td)
{
(void)so;
(void)nam;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_connect_notsupp(struct socket *so, struct ofp_sockaddr *nam, struct thread *td)
{
(void)so;
(void)nam;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_connect2_notsupp(struct socket *so1, struct socket *so2)
{
(void)so1;
(void)so2;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_control_notsupp(struct socket *so, uint32_t cmd, char * data,
struct ofp_ifnet *ifp, struct thread *td)
{
(void)so;
(void)cmd;
(void)data;
(void)ifp;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_disconnect_notsupp(struct socket *so)
{
(void)so;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_listen_notsupp(struct socket *so, int backlog, struct thread *td)
{
(void)so;
(void)backlog;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_peeraddr_notsupp(struct socket *so, struct ofp_sockaddr **nam)
{
(void)so;
(void)nam;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_rcvd_notsupp(struct socket *so, int flags)
{
(void)so;
(void)flags;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_rcvoob_notsupp(struct socket *so, odp_packet_t m, int flags)
{
(void)so;
(void)m;
(void)flags;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_send_notsupp(struct socket *so, int flags, odp_packet_t m,
struct ofp_sockaddr *addr, odp_packet_t control, struct thread *td)
{
(void)so;
(void)m;
(void)flags;
(void)addr;
(void)control;
(void)td;
return OFP_EOPNOTSUPP;
}
/*
* This isn't really a ``null'' operation, but it's the default one and
* doesn't do anything destructive.
*/
int
ofp_pru_sense_null(struct socket *so, struct stat *sb)
{
/*sb->st_blksize = so->so_snd.sb_hiwat;*/
(void)so;
(void)sb;
return 0;
}
int
ofp_pru_shutdown_notsupp(struct socket *so)
{
(void)so;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_sockaddr_notsupp(struct socket *so, struct ofp_sockaddr **nam)
{
(void)so;
(void)nam;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_sosend_notsupp(struct socket *so, struct ofp_sockaddr *addr,
struct uio *uio, odp_packet_t top, odp_packet_t control, int flags,
struct thread *td)
{
(void)so;
(void)addr;
(void)uio;
(void)top;
(void)control;
(void)flags;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_soreceive_notsupp(struct socket *so, struct ofp_sockaddr **paddr,
struct uio *uio, odp_packet_t *mp0, odp_packet_t *controlp, int *flagsp)
{
(void)so;
(void)paddr;
(void)uio;
(void)mp0;
(void)controlp;
(void)flagsp;
return OFP_EOPNOTSUPP;
}
int
ofp_pru_sopoll_notsupp(struct socket *so, int events, struct ofp_ucred *cred,
struct thread *td)
{
(void)so;
(void)events;
(void)cred;
(void)td;
return OFP_EOPNOTSUPP;
}
int
ofp_send_sock_event(struct socket *head, struct socket *so, int event)
{
struct ofp_sigevent *ev = &head->so_sigevent;
if (ev->ofp_sigev_notify) {
union ofp_sigval sv;
struct ofp_sock_sigval ss;
sv.sival_ptr = (void *)&ss;
ss.event = event;
ss.sockfd = head->so_number;
ss.sockfd2 = so->so_number;
so->so_state |= SS_EVENT;
head->so_state |= SS_EVENT;
ev->ofp_sigev_notify_function(sv);
so->so_state &= ~SS_EVENT;
head->so_state &= ~SS_EVENT;
}
return 0;
}
static inline int
is_accepting_socket(struct socket *so)
{
return (so->so_options & OFP_SO_ACCEPTCONN);
}
static inline int
is_accepting_socket_readable(struct socket *so)
{
return !(OFP_TAILQ_EMPTY(&so->so_comp));
}
static inline int
is_listening_socket_readable(struct socket *so)
{
return (so->so_rcv.sb_cc > 0);
}
int
is_readable(int fd)
{
struct socket *so = ofp_get_sock_by_fd(fd);
if (is_accepting_socket(so))
return is_accepting_socket_readable(so);
return is_listening_socket_readable(so);
}
|
496657.c | /* GNU Objective C Runtime message lookup
Copyright (C) 1993-2017 Free Software Foundation, Inc.
Contributed by Kresten Krab Thorup
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
/* Uncommented the following line to enable debug logging. Use this
only while debugging the runtime. */
/* #define DEBUG 1 */
/* FIXME: This should be using libffi instead of __builtin_apply
and friends. */
#include "objc-private/common.h"
#include "objc-private/error.h"
#include "tconfig.h"
#include "coretypes.h"
#include "objc/runtime.h"
#include "objc/message.h" /* For objc_msg_lookup(), objc_msg_lookup_super(). */
#include "objc/thr.h"
#include "objc-private/module-abi-8.h"
#include "objc-private/runtime.h"
#include "objc-private/hash.h"
#include "objc-private/sarray.h"
#include "objc-private/selector.h" /* For sel_is_mapped() */
#include "runtime-info.h"
#include <assert.h> /* For assert */
#include <string.h> /* For strlen */
#define INVISIBLE_STRUCT_RETURN 1
/* The uninstalled dispatch table. If a class' dispatch table points
to __objc_uninstalled_dtable then that means it needs its dispatch
table to be installed. */
struct sarray *__objc_uninstalled_dtable = 0; /* !T:MUTEX */
/* Two hooks for method forwarding. If either is set, it is invoked to
* return a function that performs the real forwarding. If both are
* set, the result of __objc_msg_forward2 will be preferred over that
* of __objc_msg_forward. If both return NULL or are unset, the
* libgcc based functions (__builtin_apply and friends) are used. */
IMP (*__objc_msg_forward) (SEL) = NULL;
IMP (*__objc_msg_forward2) (id, SEL) = NULL;
/* Send +initialize to class. */
static void __objc_send_initialize (Class);
/* Forward declare some functions */
static void __objc_install_dtable_for_class (Class cls);
static void __objc_prepare_dtable_for_class (Class cls);
static void __objc_install_prepared_dtable_for_class (Class cls);
static struct sarray *__objc_prepared_dtable_for_class (Class cls);
static IMP __objc_get_prepared_imp (Class cls,SEL sel);
/* Various forwarding functions that are used based upon the
return type for the selector.
__objc_block_forward for structures.
__objc_double_forward for floats/doubles.
__objc_word_forward for pointers or types that fit in registers. */
static double __objc_double_forward (id, SEL, ...);
static id __objc_word_forward (id, SEL, ...);
typedef struct { id many[8]; } __big;
#if INVISIBLE_STRUCT_RETURN
static __big
#else
static id
#endif
__objc_block_forward (id, SEL, ...);
static struct objc_method * search_for_method_in_hierarchy (Class class, SEL sel);
struct objc_method * search_for_method_in_list (struct objc_method_list * list, SEL op);
id nil_method (id, SEL);
/* Make sure this inline function is exported regardless of GNU89 or C99
inlining semantics as it is part of the libobjc ABI. */
extern IMP __objc_get_forward_imp (id, SEL);
/* Given a selector, return the proper forwarding implementation. */
inline
IMP
__objc_get_forward_imp (id rcv, SEL sel)
{
/* If a custom forwarding hook was registered, try getting a
forwarding function from it. There are two forward routine hooks,
one that takes the receiver as an argument and one that does
not. */
if (__objc_msg_forward2)
{
IMP result;
if ((result = __objc_msg_forward2 (rcv, sel)) != NULL)
return result;
}
if (__objc_msg_forward)
{
IMP result;
if ((result = __objc_msg_forward (sel)) != NULL)
return result;
}
/* In all other cases, use the default forwarding functions built
using __builtin_apply and friends. */
{
const char *t = sel->sel_types;
if (t && (*t == '[' || *t == '(' || *t == '{')
#ifdef OBJC_MAX_STRUCT_BY_VALUE
&& objc_sizeof_type (t) > OBJC_MAX_STRUCT_BY_VALUE
#endif
)
return (IMP)__objc_block_forward;
else if (t && (*t == 'f' || *t == 'd'))
return (IMP)__objc_double_forward;
else
return (IMP)__objc_word_forward;
}
}
/* Selectors for +resolveClassMethod: and +resolveInstanceMethod:.
These are set up at startup. */
static SEL selector_resolveClassMethod = NULL;
static SEL selector_resolveInstanceMethod = NULL;
/* Internal routines use to resolve a class method using
+resolveClassMethod:. 'class' is always a non-Nil class (*not* a
meta-class), and 'sel' is the selector that we are trying to
resolve. This must be called when class is not Nil, and the
dispatch table for class methods has already been installed.
This routine tries to call +resolveClassMethod: to give an
opportunity to resolve the method. If +resolveClassMethod: returns
YES, it tries looking up the method again, and if found, it returns
it. Else, it returns NULL. */
static inline
IMP
__objc_resolve_class_method (Class class, SEL sel)
{
/* We need to lookup +resolveClassMethod:. */
BOOL (*resolveMethodIMP) (id, SEL, SEL);
/* The dispatch table for class methods is already installed and we
don't want any forwarding to happen when looking up this method,
so we just look it up directly. Note that if 'sel' is precisely
+resolveClassMethod:, this would look it up yet again and find
nothing. That's no problem and there's no recursion. */
resolveMethodIMP = (BOOL (*) (id, SEL, SEL))sarray_get_safe
(class->class_pointer->dtable, (size_t) selector_resolveClassMethod->sel_id);
if (resolveMethodIMP && resolveMethodIMP ((id)class, selector_resolveClassMethod, sel))
{
/* +resolveClassMethod: returned YES. Look the method up again.
We already know the dtable is installed. */
/* TODO: There is the case where +resolveClassMethod: is buggy
and returned YES without actually adding the method. We
could maybe print an error message. */
return sarray_get_safe (class->class_pointer->dtable, (size_t) sel->sel_id);
}
return NULL;
}
/* Internal routines use to resolve a instance method using
+resolveInstanceMethod:. 'class' is always a non-Nil class, and
'sel' is the selector that we are trying to resolve. This must be
called when class is not Nil, and the dispatch table for instance
methods has already been installed.
This routine tries to call +resolveInstanceMethod: to give an
opportunity to resolve the method. If +resolveInstanceMethod:
returns YES, it tries looking up the method again, and if found, it
returns it. Else, it returns NULL. */
static inline
IMP
__objc_resolve_instance_method (Class class, SEL sel)
{
/* We need to lookup +resolveInstanceMethod:. */
BOOL (*resolveMethodIMP) (id, SEL, SEL);
/* The dispatch table for class methods may not be already installed
so we have to install it if needed. */
resolveMethodIMP = sarray_get_safe (class->class_pointer->dtable,
(size_t) selector_resolveInstanceMethod->sel_id);
if (resolveMethodIMP == 0)
{
/* Try again after installing the dtable. */
if (class->class_pointer->dtable == __objc_uninstalled_dtable)
{
objc_mutex_lock (__objc_runtime_mutex);
if (class->class_pointer->dtable == __objc_uninstalled_dtable)
__objc_install_dtable_for_class (class->class_pointer);
objc_mutex_unlock (__objc_runtime_mutex);
}
resolveMethodIMP = sarray_get_safe (class->class_pointer->dtable,
(size_t) selector_resolveInstanceMethod->sel_id);
}
if (resolveMethodIMP && resolveMethodIMP ((id)class, selector_resolveInstanceMethod, sel))
{
/* +resolveInstanceMethod: returned YES. Look the method up
again. We already know the dtable is installed. */
/* TODO: There is the case where +resolveInstanceMethod: is
buggy and returned YES without actually adding the method.
We could maybe print an error message. */
return sarray_get_safe (class->dtable, (size_t) sel->sel_id);
}
return NULL;
}
/* Given a CLASS and selector, return the implementation corresponding
to the method of the selector.
If CLASS is a class, the instance method is returned.
If CLASS is a meta class, the class method is returned.
Since this requires the dispatch table to be installed, this function
will implicitly invoke +initialize for CLASS if it hasn't been
invoked yet. This also insures that +initialize has been invoked
when the returned implementation is called directly.
The forwarding hooks require the receiver as an argument (if they are to
perform dynamic lookup in proxy objects etc), so this function has a
receiver argument to be used with those hooks. */
static inline
IMP
get_implementation (id receiver, Class class, SEL sel)
{
void *res;
if (class->dtable == __objc_uninstalled_dtable)
{
/* The dispatch table needs to be installed. */
objc_mutex_lock (__objc_runtime_mutex);
/* Double-checked locking pattern: Check
__objc_uninstalled_dtable again in case another thread
installed the dtable while we were waiting for the lock to be
released. */
if (class->dtable == __objc_uninstalled_dtable)
__objc_install_dtable_for_class (class);
/* If the dispatch table is not yet installed, we are still in
the process of executing +initialize. But the implementation
pointer should be available in the prepared ispatch table if
it exists at all. */
if (class->dtable == __objc_uninstalled_dtable)
{
assert (__objc_prepared_dtable_for_class (class) != 0);
res = __objc_get_prepared_imp (class, sel);
}
else
res = 0;
objc_mutex_unlock (__objc_runtime_mutex);
/* Call ourselves with the installed dispatch table and get the
real method. */
if (!res)
res = get_implementation (receiver, class, sel);
}
else
{
/* The dispatch table has been installed. */
res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
if (res == 0)
{
/* The dispatch table has been installed, and the method is
not in the dispatch table. So the method just doesn't
exist for the class. */
/* Try going through the +resolveClassMethod: or
+resolveInstanceMethod: process. */
if (CLS_ISMETA (class))
{
/* We have the meta class, but we need to invoke the
+resolveClassMethod: method on the class. So, we
need to obtain the class from the meta class, which
we do using the fact that both the class and the
meta-class have the same name. */
Class realClass = objc_lookUpClass (class->name);
if (realClass)
res = __objc_resolve_class_method (realClass, sel);
}
else
res = __objc_resolve_instance_method (class, sel);
if (res == 0)
res = __objc_get_forward_imp (receiver, sel);
}
}
return res;
}
/* Make sure this inline function is exported regardless of GNU89 or C99
inlining semantics as it is part of the libobjc ABI. */
extern IMP get_imp (Class, SEL);
inline
IMP
get_imp (Class class, SEL sel)
{
/* In a vanilla implementation we would first check if the dispatch
table is installed. Here instead, to get more speed in the
standard case (that the dispatch table is installed) we first try
to get the imp using brute force. Only if that fails, we do what
we should have been doing from the very beginning, that is, check
if the dispatch table needs to be installed, install it if it's
not installed, and retrieve the imp from the table if it's
installed. */
void *res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
if (res == 0)
{
res = get_implementation(nil, class, sel);
}
return res;
}
/* The new name of get_imp(). */
IMP
class_getMethodImplementation (Class class_, SEL selector)
{
if (class_ == Nil || selector == NULL)
return NULL;
/* get_imp is inlined, so we're good. */
return get_imp (class_, selector);
}
/* Given a method, return its implementation. This has been replaced
by method_getImplementation() in the modern API. */
IMP
method_get_imp (struct objc_method * method)
{
return (method != (struct objc_method *)0) ? method->method_imp : (IMP)0;
}
/* Query if an object can respond to a selector, returns YES if the
object implements the selector otherwise NO. Does not check if the
method can be forwarded. Since this requires the dispatch table to
installed, this function will implicitly invoke +initialize for the
class of OBJECT if it hasn't been invoked yet. */
inline
BOOL
__objc_responds_to (id object, SEL sel)
{
void *res;
struct sarray *dtable;
/* Install dispatch table if need be */
dtable = object->class_pointer->dtable;
if (dtable == __objc_uninstalled_dtable)
{
objc_mutex_lock (__objc_runtime_mutex);
if (object->class_pointer->dtable == __objc_uninstalled_dtable)
__objc_install_dtable_for_class (object->class_pointer);
/* If the dispatch table is not yet installed, we are still in
the process of executing +initialize. Yet the dispatch table
should be available. */
if (object->class_pointer->dtable == __objc_uninstalled_dtable)
{
dtable = __objc_prepared_dtable_for_class (object->class_pointer);
assert (dtable);
}
else
dtable = object->class_pointer->dtable;
objc_mutex_unlock (__objc_runtime_mutex);
}
/* Get the method from the dispatch table. */
res = sarray_get_safe (dtable, (size_t) sel->sel_id);
return (res != 0) ? YES : NO;
}
BOOL
class_respondsToSelector (Class class_, SEL selector)
{
struct sarray *dtable;
void *res;
if (class_ == Nil || selector == NULL)
return NO;
/* Install dispatch table if need be. */
dtable = class_->dtable;
if (dtable == __objc_uninstalled_dtable)
{
objc_mutex_lock (__objc_runtime_mutex);
if (class_->dtable == __objc_uninstalled_dtable)
__objc_install_dtable_for_class (class_);
/* If the dispatch table is not yet installed,
we are still in the process of executing +initialize.
Yet the dispatch table should be available. */
if (class_->dtable == __objc_uninstalled_dtable)
{
dtable = __objc_prepared_dtable_for_class (class_);
assert (dtable);
}
else
dtable = class_->dtable;
objc_mutex_unlock (__objc_runtime_mutex);
}
/* Get the method from the dispatch table. */
res = sarray_get_safe (dtable, (size_t) selector->sel_id);
return (res != 0) ? YES : NO;
}
/* This is the lookup function. All entries in the table are either a
valid method *or* zero. If zero then either the dispatch table
needs to be installed or it doesn't exist and forwarding is
attempted. */
IMP
objc_msg_lookup (id receiver, SEL op)
{
IMP result;
if (receiver)
{
/* First try a quick lookup assuming the dispatch table exists. */
result = sarray_get_safe (receiver->class_pointer->dtable,
(sidx)op->sel_id);
if (result == 0)
{
/* Not found ... call get_implementation () to install the
dispatch table and call +initialize as required,
providing the method implementation or a forwarding
function. */
result = get_implementation (receiver, receiver->class_pointer, op);
}
return result;
}
else
return (IMP)nil_method;
}
IMP
objc_msg_lookup_super (struct objc_super *super, SEL sel)
{
if (super->self)
return get_imp (super->super_class, sel);
else
return (IMP)nil_method;
}
void
__objc_init_dispatch_tables ()
{
__objc_uninstalled_dtable = sarray_new (200, 0);
/* TODO: It would be cool to register typed selectors here. */
selector_resolveClassMethod = sel_registerName ("resolveClassMethod:");
selector_resolveInstanceMethod = sel_registerName ("resolveInstanceMethod:");
}
/* Install dummy table for class which causes the first message to
that class (or instances hereof) to be initialized properly. */
void
__objc_install_premature_dtable (Class class)
{
assert (__objc_uninstalled_dtable);
class->dtable = __objc_uninstalled_dtable;
}
/* Send +initialize to class if not already done. */
static void
__objc_send_initialize (Class class)
{
/* This *must* be a class object. */
assert (CLS_ISCLASS (class));
assert (! CLS_ISMETA (class));
/* class_add_method_list/__objc_update_dispatch_table_for_class may
have reset the dispatch table. The canonical way to insure that
we send +initialize just once, is this flag. */
if (! CLS_ISINITIALIZED (class))
{
DEBUG_PRINTF ("+initialize: need to initialize class '%s'\n", class->name);
CLS_SETINITIALIZED (class);
CLS_SETINITIALIZED (class->class_pointer);
/* Create the garbage collector type memory description. */
__objc_generate_gc_type_description (class);
if (class->super_class)
__objc_send_initialize (class->super_class);
{
SEL op = sel_registerName ("initialize");
struct objc_method *method = search_for_method_in_hierarchy (class->class_pointer,
op);
if (method)
{
DEBUG_PRINTF (" begin of [%s +initialize]\n", class->name);
(*method->method_imp) ((id)class, op);
DEBUG_PRINTF (" end of [%s +initialize]\n", class->name);
}
#ifdef DEBUG
else
{
DEBUG_PRINTF (" class '%s' has no +initialize method\n", class->name);
}
#endif
}
}
}
/* Walk on the methods list of class and install the methods in the
reverse order of the lists. Since methods added by categories are
before the methods of class in the methods list, this allows
categories to substitute methods declared in class. However if
more than one category replaces the same method nothing is
guaranteed about what method will be used. Assumes that
__objc_runtime_mutex is locked down. */
static void
__objc_install_methods_in_dtable (struct sarray *dtable, struct objc_method_list * method_list)
{
int i;
if (! method_list)
return;
if (method_list->method_next)
__objc_install_methods_in_dtable (dtable, method_list->method_next);
for (i = 0; i < method_list->method_count; i++)
{
struct objc_method * method = &(method_list->method_list[i]);
sarray_at_put_safe (dtable,
(sidx) method->method_name->sel_id,
method->method_imp);
}
}
void
__objc_update_dispatch_table_for_class (Class class)
{
Class next;
struct sarray *arr;
DEBUG_PRINTF (" _objc_update_dtable_for_class (%s)\n", class->name);
objc_mutex_lock (__objc_runtime_mutex);
/* Not yet installed -- skip it unless in +initialize. */
if (class->dtable == __objc_uninstalled_dtable)
{
if (__objc_prepared_dtable_for_class (class))
{
/* There is a prepared table so we must be initialising this
class ... we must re-do the table preparation. */
__objc_prepare_dtable_for_class (class);
}
objc_mutex_unlock (__objc_runtime_mutex);
return;
}
arr = class->dtable;
__objc_install_premature_dtable (class); /* someone might require it... */
sarray_free (arr); /* release memory */
/* Could have been lazy... */
__objc_install_dtable_for_class (class);
if (class->subclass_list) /* Traverse subclasses. */
for (next = class->subclass_list; next; next = next->sibling_class)
__objc_update_dispatch_table_for_class (next);
objc_mutex_unlock (__objc_runtime_mutex);
}
/* This function adds a method list to a class. This function is
typically called by another function specific to the run-time. As
such this function does not worry about thread safe issues.
This one is only called for categories. Class objects have their
methods installed right away, and their selectors are made into
SEL's by the function __objc_register_selectors_from_class. */
void
class_add_method_list (Class class, struct objc_method_list * list)
{
/* Passing of a linked list is not allowed. Do multiple calls. */
assert (! list->method_next);
__objc_register_selectors_from_list(list);
/* Add the methods to the class's method list. */
list->method_next = class->methods;
class->methods = list;
/* Update the dispatch table of class. */
__objc_update_dispatch_table_for_class (class);
}
struct objc_method *
class_getInstanceMethod (Class class_, SEL selector)
{
struct objc_method *m;
if (class_ == Nil || selector == NULL)
return NULL;
m = search_for_method_in_hierarchy (class_, selector);
if (m)
return m;
/* Try going through +resolveInstanceMethod:, and do the search
again if successful. */
if (__objc_resolve_instance_method (class_, selector))
return search_for_method_in_hierarchy (class_, selector);
return NULL;
}
struct objc_method *
class_getClassMethod (Class class_, SEL selector)
{
struct objc_method *m;
if (class_ == Nil || selector == NULL)
return NULL;
m = search_for_method_in_hierarchy (class_->class_pointer,
selector);
if (m)
return m;
/* Try going through +resolveClassMethod:, and do the search again
if successful. */
if (__objc_resolve_class_method (class_, selector))
return search_for_method_in_hierarchy (class_->class_pointer,
selector);
return NULL;
}
BOOL
class_addMethod (Class class_, SEL selector, IMP implementation,
const char *method_types)
{
struct objc_method_list *method_list;
struct objc_method *method;
const char *method_name;
if (class_ == Nil || selector == NULL || implementation == NULL
|| method_types == NULL || (strcmp (method_types, "") == 0))
return NO;
method_name = sel_getName (selector);
if (method_name == NULL)
return NO;
/* If the method already exists in the class, return NO. It is fine
if the method already exists in the superclass; in that case, we
are overriding it. */
if (CLS_IS_IN_CONSTRUCTION (class_))
{
/* The class only contains a list of methods; they have not been
registered yet, ie, the method_name of each of them is still
a string, not a selector. Iterate manually over them to
check if we have already added the method. */
struct objc_method_list * method_list = class_->methods;
while (method_list)
{
int i;
/* Search the method list. */
for (i = 0; i < method_list->method_count; ++i)
{
struct objc_method * method = &method_list->method_list[i];
if (method->method_name
&& strcmp ((char *)method->method_name, method_name) == 0)
return NO;
}
/* The method wasn't found. Follow the link to the next list of
methods. */
method_list = method_list->method_next;
}
/* The method wasn't found. It's a new one. Go ahead and add
it. */
}
else
{
/* Do the standard lookup. This assumes the selectors are
mapped. */
if (search_for_method_in_list (class_->methods, selector))
return NO;
}
method_list = (struct objc_method_list *)objc_calloc (1, sizeof (struct objc_method_list));
method_list->method_count = 1;
method = &(method_list->method_list[0]);
method->method_name = objc_malloc (strlen (method_name) + 1);
strcpy ((char *)method->method_name, method_name);
method->method_types = objc_malloc (strlen (method_types) + 1);
strcpy ((char *)method->method_types, method_types);
method->method_imp = implementation;
if (CLS_IS_IN_CONSTRUCTION (class_))
{
/* We only need to add the method to the list. It will be
registered with the runtime when the class pair is registered
(if ever). */
method_list->method_next = class_->methods;
class_->methods = method_list;
}
else
{
/* Add the method to a live class. */
objc_mutex_lock (__objc_runtime_mutex);
class_add_method_list (class_, method_list);
objc_mutex_unlock (__objc_runtime_mutex);
}
return YES;
}
IMP
class_replaceMethod (Class class_, SEL selector, IMP implementation,
const char *method_types)
{
struct objc_method * method;
if (class_ == Nil || selector == NULL || implementation == NULL
|| method_types == NULL)
return NULL;
method = search_for_method_in_hierarchy (class_, selector);
if (method)
{
return method_setImplementation (method, implementation);
}
else
{
class_addMethod (class_, selector, implementation, method_types);
return NULL;
}
}
/* Search for a method starting from the current class up its
hierarchy. Return a pointer to the method's method structure if
found. NULL otherwise. */
static struct objc_method *
search_for_method_in_hierarchy (Class cls, SEL sel)
{
struct objc_method * method = NULL;
Class class;
if (! sel_is_mapped (sel))
return NULL;
/* Scan the method list of the class. If the method isn't found in
the list then step to its super class. */
for (class = cls; ((! method) && class); class = class->super_class)
method = search_for_method_in_list (class->methods, sel);
return method;
}
/* Given a linked list of method and a method's name. Search for the
named method's method structure. Return a pointer to the method's
method structure if found. NULL otherwise. */
struct objc_method *
search_for_method_in_list (struct objc_method_list * list, SEL op)
{
struct objc_method_list * method_list = list;
if (! sel_is_mapped (op))
return NULL;
/* If not found then we'll search the list. */
while (method_list)
{
int i;
/* Search the method list. */
for (i = 0; i < method_list->method_count; ++i)
{
struct objc_method * method = &method_list->method_list[i];
if (method->method_name)
if (method->method_name->sel_id == op->sel_id)
return method;
}
/* The method wasn't found. Follow the link to the next list of
methods. */
method_list = method_list->method_next;
}
return NULL;
}
typedef void * retval_t;
typedef void * arglist_t;
static retval_t __objc_forward (id object, SEL sel, arglist_t args);
/* Forwarding pointers/integers through the normal registers. */
static id
__objc_word_forward (id rcv, SEL op, ...)
{
void *args, *res;
args = __builtin_apply_args ();
res = __objc_forward (rcv, op, args);
if (res)
__builtin_return (res);
else
return res;
}
/* Specific routine for forwarding floats/double because of
architectural differences on some processors. i386s for example
which uses a floating point stack versus general registers for
floating point numbers. This forward routine makes sure that GCC
restores the proper return values. */
static double
__objc_double_forward (id rcv, SEL op, ...)
{
void *args, *res;
args = __builtin_apply_args ();
res = __objc_forward (rcv, op, args);
__builtin_return (res);
}
#if INVISIBLE_STRUCT_RETURN
static __big
#else
static id
#endif
__objc_block_forward (id rcv, SEL op, ...)
{
void *args, *res;
args = __builtin_apply_args ();
res = __objc_forward (rcv, op, args);
if (res)
__builtin_return (res);
else
#if INVISIBLE_STRUCT_RETURN
return (__big) {{0, 0, 0, 0, 0, 0, 0, 0}};
#else
return nil;
#endif
}
/* This function is called for methods which are not implemented,
unless a custom forwarding routine has been installed. Please note
that most serious users of libobjc (eg, GNUstep base) do install
their own forwarding routines, and hence this is never actually
used. But, if no custom forwarding routine is installed, this is
called when a selector is not recognized. */
static retval_t
__objc_forward (id object, SEL sel, arglist_t args)
{
IMP imp;
static SEL frwd_sel = 0; /* !T:SAFE2 */
SEL err_sel;
/* First try if the object understands forward::. */
if (! frwd_sel)
frwd_sel = sel_get_any_uid ("forward::");
if (__objc_responds_to (object, frwd_sel))
{
imp = get_implementation (object, object->class_pointer, frwd_sel);
return (*imp) (object, frwd_sel, sel, args);
}
/* If the object recognizes the doesNotRecognize: method then we're
going to send it. */
err_sel = sel_get_any_uid ("doesNotRecognize:");
if (__objc_responds_to (object, err_sel))
{
imp = get_implementation (object, object->class_pointer, err_sel);
return (*imp) (object, err_sel, sel);
}
/* The object doesn't recognize the method. Check for responding to
error:. If it does then sent it. */
{
char msg[256 + strlen ((const char *) sel_getName (sel))
+ strlen ((const char *) object->class_pointer->name)];
sprintf (msg, "(%s) %s does not recognize %s",
(CLS_ISMETA (object->class_pointer)
? "class"
: "instance" ),
object->class_pointer->name, sel_getName (sel));
/* The object doesn't respond to doesNotRecognize:. Therefore, a
default action is taken. */
_objc_abort ("%s\n", msg);
return 0;
}
}
void
__objc_print_dtable_stats (void)
{
int total = 0;
objc_mutex_lock (__objc_runtime_mutex);
#ifdef OBJC_SPARSE2
printf ("memory usage: (%s)\n", "2-level sparse arrays");
#else
printf ("memory usage: (%s)\n", "3-level sparse arrays");
#endif
printf ("arrays: %d = %ld bytes\n", narrays,
(long) ((size_t) narrays * sizeof (struct sarray)));
total += narrays * sizeof (struct sarray);
printf ("buckets: %d = %ld bytes\n", nbuckets,
(long) ((size_t) nbuckets * sizeof (struct sbucket)));
total += nbuckets * sizeof (struct sbucket);
printf ("idxtables: %d = %ld bytes\n",
idxsize, (long) ((size_t) idxsize * sizeof (void *)));
total += idxsize * sizeof (void *);
printf ("-----------------------------------\n");
printf ("total: %d bytes\n", total);
printf ("===================================\n");
objc_mutex_unlock (__objc_runtime_mutex);
}
static cache_ptr prepared_dtable_table = 0;
/* This function is called by: objc_msg_lookup, get_imp and
__objc_responds_to (and the dispatch table installation functions
themselves) to install a dispatch table for a class.
If CLS is a class, it installs instance methods.
If CLS is a meta class, it installs class methods.
In either case +initialize is invoked for the corresponding class.
The implementation must insure that the dispatch table is not
installed until +initialize completes. Otherwise it opens a
potential race since the installation of the dispatch table is used
as gate in regular method dispatch and we need to guarantee that
+initialize is the first method invoked an that no other thread my
dispatch messages to the class before +initialize completes. */
static void
__objc_install_dtable_for_class (Class cls)
{
/* If the class has not yet had its class links resolved, we must
re-compute all class links. */
if (! CLS_ISRESOLV (cls))
__objc_resolve_class_links ();
/* Make sure the super class has its dispatch table installed or is
at least preparing. We do not need to send initialize for the
super class since __objc_send_initialize will insure that. */
if (cls->super_class
&& cls->super_class->dtable == __objc_uninstalled_dtable
&& !__objc_prepared_dtable_for_class (cls->super_class))
{
__objc_install_dtable_for_class (cls->super_class);
/* The superclass initialisation may have also initialised the
current class, in which case there is no more to do. */
if (cls->dtable != __objc_uninstalled_dtable)
return;
}
/* We have already been prepared but +initialize hasn't completed.
The +initialize implementation is probably sending 'self'
messages. We rely on _objc_get_prepared_imp to retrieve the
implementation pointers. */
if (__objc_prepared_dtable_for_class (cls))
return;
/* We have this function cache the implementation pointers for
_objc_get_prepared_imp but the dispatch table won't be initilized
until __objc_send_initialize completes. */
__objc_prepare_dtable_for_class (cls);
/* We may have already invoked +initialize but
__objc_update_dispatch_table_for_class invoked by
class_add_method_list may have reset dispatch table. */
/* Call +initialize. If we are a real class, we are installing
instance methods. If we are a meta class, we are installing
class methods. The __objc_send_initialize itself will insure
that the message is called only once per class. */
if (CLS_ISCLASS (cls))
__objc_send_initialize (cls);
else
{
/* Retrieve the class from the meta class. */
Class c = objc_getClass (cls->name);
assert (CLS_ISMETA (cls));
assert (c);
__objc_send_initialize (c);
}
/* We install the dispatch table correctly when +initialize completed. */
__objc_install_prepared_dtable_for_class (cls);
}
/* Builds the dispatch table for the class CLS and stores it in a
place where it can be retrieved by __objc_get_prepared_imp until
__objc_install_prepared_dtable_for_class installs it into the
class. The dispatch table should not be installed into the class
until +initialize has completed. */
static void
__objc_prepare_dtable_for_class (Class cls)
{
struct sarray *dtable;
struct sarray *super_dtable;
/* This table could be initialized in init.c. We can not use the
class name since the class maintains the instance methods and the
meta class maintains the the class methods yet both share the
same name. Classes should be unique in any program. */
if (! prepared_dtable_table)
prepared_dtable_table
= objc_hash_new (32,
(hash_func_type) objc_hash_ptr,
(compare_func_type) objc_compare_ptrs);
/* If the class has not yet had its class links resolved, we must
re-compute all class links. */
if (! CLS_ISRESOLV (cls))
__objc_resolve_class_links ();
assert (cls);
assert (cls->dtable == __objc_uninstalled_dtable);
/* If there is already a prepared dtable for this class, we must
replace it with a new version (since there must have been methods
added to or otherwise modified in the class while executing
+initialize, and the table needs to be recomputed. */
dtable = __objc_prepared_dtable_for_class (cls);
if (dtable != 0)
{
objc_hash_remove (prepared_dtable_table, cls);
sarray_free (dtable);
}
/* Now prepare the dtable for population. */
assert (cls != cls->super_class);
if (cls->super_class)
{
/* Inherit the method list from the super class. Yet the super
class may still be initializing in the case when a class
cluster sub class initializes its super classes. */
if (cls->super_class->dtable == __objc_uninstalled_dtable)
__objc_install_dtable_for_class (cls->super_class);
super_dtable = cls->super_class->dtable;
/* If the dispatch table is not yet installed, we are still in
the process of executing +initialize. Yet the dispatch table
should be available. */
if (super_dtable == __objc_uninstalled_dtable)
super_dtable = __objc_prepared_dtable_for_class (cls->super_class);
assert (super_dtable);
dtable = sarray_lazy_copy (super_dtable);
}
else
dtable = sarray_new (__objc_selector_max_index, 0);
__objc_install_methods_in_dtable (dtable, cls->methods);
objc_hash_add (&prepared_dtable_table,
cls,
dtable);
}
/* This wrapper only exists to allow an easy replacement of the lookup
implementation and it is expected that the compiler will optimize
it away. */
static struct sarray *
__objc_prepared_dtable_for_class (Class cls)
{
struct sarray *dtable = 0;
assert (cls);
if (prepared_dtable_table)
dtable = objc_hash_value_for_key (prepared_dtable_table, cls);
/* dtable my be nil, since we call this to check whether we are
currently preparing before we start preparing. */
return dtable;
}
/* Helper function for messages sent to CLS or implementation pointers
retrieved from CLS during +initialize before the dtable is
installed. When a class implicitly initializes another class which
in turn implicitly invokes methods in this class, before the
implementation of +initialize of CLS completes, this returns the
expected implementation. Forwarding remains the responsibility of
objc_msg_lookup. This function should only be called under the
global lock. */
static IMP
__objc_get_prepared_imp (Class cls,SEL sel)
{
struct sarray *dtable;
IMP imp;
assert (cls);
assert (sel);
assert (cls->dtable == __objc_uninstalled_dtable);
dtable = __objc_prepared_dtable_for_class (cls);
assert (dtable);
assert (dtable != __objc_uninstalled_dtable);
imp = sarray_get_safe (dtable, (size_t) sel->sel_id);
/* imp may be Nil if the method does not exist and we may fallback
to the forwarding implementation later. */
return imp;
}
/* When this function is called +initialize should be completed. So
now we are safe to install the dispatch table for the class so that
they become available for other threads that may be waiting in the
lock. */
static void
__objc_install_prepared_dtable_for_class (Class cls)
{
assert (cls);
assert (cls->dtable == __objc_uninstalled_dtable);
cls->dtable = __objc_prepared_dtable_for_class (cls);
assert (cls->dtable);
assert (cls->dtable != __objc_uninstalled_dtable);
objc_hash_remove (prepared_dtable_table, cls);
}
|
924569.c | /* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ecma-alloc.h"
#include "ecma-builtins.h"
#include "ecma-conversion.h"
#include "ecma-exceptions.h"
#include "ecma-helpers.h"
#include "ecma-objects.h"
#include "ecma-regexp-object.h"
#include "ecma-try-catch-macro.h"
#ifndef CONFIG_DISABLE_REGEXP_BUILTIN
#define ECMA_BUILTINS_INTERNAL
#include "ecma-builtins-internal.h"
#define BUILTIN_INC_HEADER_NAME "ecma-builtin-regexp.inc.h"
#define BUILTIN_UNDERSCORED_ID regexp
#include "ecma-builtin-internal-routines-template.inc.h"
/** \addtogroup ecma ECMA
* @{
*
* \addtogroup ecmabuiltins
* @{
*
* \addtogroup regexp ECMA RegExp object built-in
* @{
*/
/**
* Handle calling [[Call]] of built-in RegExp object
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
ecma_value_t
ecma_builtin_regexp_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< number of arguments */
{
return ecma_builtin_regexp_dispatch_construct (arguments_list_p, arguments_list_len);
} /* ecma_builtin_regexp_dispatch_call */
/**
* Handle calling [[Construct]] of built-in RegExp object
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
ecma_value_t
ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< number of arguments */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
ecma_value_t pattern_value = ECMA_VALUE_UNDEFINED;
ecma_value_t flags_value = ECMA_VALUE_UNDEFINED;
if (arguments_list_len > 0)
{
/* pattern string or RegExp object */
pattern_value = arguments_list_p[0];
if (arguments_list_len > 1)
{
flags_value = arguments_list_p[1];
}
}
if (ecma_is_value_object (pattern_value)
&& ecma_object_class_is (ecma_get_object_from_value (pattern_value), LIT_MAGIC_STRING_REGEXP_UL))
{
if (ecma_is_value_undefined (flags_value))
{
ret_value = ecma_copy_value (pattern_value);
}
else
{
ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp call."));
}
}
else
{
ecma_string_t *pattern_string_p = NULL;
ecma_string_t *flags_string_p = NULL;
if (!ecma_is_value_undefined (pattern_value))
{
ECMA_TRY_CATCH (regexp_str_value,
ecma_op_to_string (pattern_value),
ret_value);
if (ecma_string_is_empty (ecma_get_string_from_value (regexp_str_value)))
{
pattern_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_EMPTY_NON_CAPTURE_GROUP);
}
else
{
pattern_string_p = ecma_get_string_from_value (regexp_str_value);
ecma_ref_ecma_string (pattern_string_p);
}
ECMA_FINALIZE (regexp_str_value);
}
else
{
pattern_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_EMPTY_NON_CAPTURE_GROUP);
}
if (ecma_is_value_empty (ret_value) && !ecma_is_value_undefined (flags_value))
{
ECMA_TRY_CATCH (flags_str_value,
ecma_op_to_string (flags_value),
ret_value);
flags_string_p = ecma_get_string_from_value (flags_str_value);
ecma_ref_ecma_string (flags_string_p);
ECMA_FINALIZE (flags_str_value);
}
if (ecma_is_value_empty (ret_value))
{
ret_value = ecma_op_create_regexp_object (pattern_string_p, flags_string_p);
}
if (pattern_string_p != NULL)
{
ecma_deref_ecma_string (pattern_string_p);
}
if (flags_string_p != NULL)
{
ecma_deref_ecma_string (flags_string_p);
}
}
return ret_value;
} /* ecma_builtin_regexp_dispatch_construct */
/**
* @}
* @}
* @}
*/
#endif /* !CONFIG_DISABLE_REGEXP_BUILTIN */
|
477099.c | /*
* Copyright (C) 2010-2021 Arm Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* ----------------------------------------------------------------------
* Project: CMSIS NN Library
* Title: arm_convolve_HWC_q7_RGB.c
* Description: Q7 version of convolution for RGB image
*
* $Date: July 20, 2021
* $Revision: V.1.1.2
*
* Target Processor: Cortex-M cores
*
* -------------------------------------------------------------------- */
#include "third_party/cmsis/CMSIS/NN/Include/arm_nnfunctions.h"
#include "third_party/cmsis/CMSIS/NN/Include/arm_nnsupportfunctions.h"
/**
* @ingroup groupNN
*/
/**
* @addtogroup NNConv
* @{
*/
/**
* @brief Q7 convolution function for RGB image
* @param[in] Im_in pointer to input tensor
* @param[in] dim_im_in input tensor dimention
* @param[in] ch_im_in number of input tensor channels
* @param[in] wt pointer to kernel weights
* @param[in] ch_im_out number of filters, i.e., output tensor channels
* @param[in] dim_kernel filter kernel size
* @param[in] padding padding sizes
* @param[in] stride convolution stride
* @param[in] bias pointer to bias
* @param[in] bias_shift amount of left-shift for bias
* @param[in] out_shift amount of right-shift for output
* @param[in,out] Im_out pointer to output tensor
* @param[in] dim_im_out output tensor dimension
* @param[in,out] bufferA pointer to buffer space for input
* @param[in,out] bufferB pointer to buffer space for output
* @return The function returns either
* <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
*
* @details
*
* <b>Buffer size:</b>
*
* bufferA size: 2*ch_im_in*dim_kernel*dim_kernel
*
* bufferB size: 0
*
* <b>Input dimension constraints:</b>
*
* ch_im_in equals 3
*
* This kernel is written exclusively for convolution with ch_im_in
* equals 3. This applies on the first layer of CNNs which has input
* image with RGB format.
*/
arm_status arm_convolve_HWC_q7_RGB(const q7_t *Im_in,
const uint16_t dim_im_in,
const uint16_t ch_im_in,
const q7_t *wt,
const uint16_t ch_im_out,
const uint16_t dim_kernel,
const uint16_t padding,
const uint16_t stride,
const q7_t *bias,
const uint16_t bias_shift,
const uint16_t out_shift,
q7_t *Im_out,
const uint16_t dim_im_out,
q15_t *bufferA,
q7_t *bufferB)
{
(void)bufferB;
#if defined(ARM_MATH_DSP) && !defined(ARM_MATH_MVEI)
/* Run the following code for Cortex-M4 and Cortex-M7 */
int16_t i_out_y, i_out_x, i_ker_y, i_ker_x;
/*
* Here we use bufferA as q15_t internally as computation are done with q15_t level
* im2col are done to output in q15_t format from q7_t input
*/
q15_t *pBuffer = bufferA;
q7_t *pOut = Im_out;
// check if number of input channels is 3
if (ch_im_in != 3)
{
return ARM_MATH_SIZE_MISMATCH;
}
// This part implements the im2col function
for (i_out_y = 0; i_out_y < dim_im_out; i_out_y++)
{
for (i_out_x = 0; i_out_x < dim_im_out; i_out_x++)
{
for (i_ker_y = i_out_y * stride - padding; i_ker_y < i_out_y * stride - padding + dim_kernel; i_ker_y++)
{
for (i_ker_x = i_out_x * stride - padding; i_ker_x < i_out_x * stride - padding + dim_kernel; i_ker_x++)
{
if (i_ker_y < 0 || i_ker_y >= dim_im_in || i_ker_x < 0 || i_ker_x >= dim_im_in)
{
/* Equivalent to arm_fill_q15(0, pBuffer, ch_im_in) with assumption: ch_im_in = 3 */
arm_memset_q7((q7_t *)pBuffer, (q7_t)0, 3 * sizeof(q15_t));
pBuffer += 3;
}
else
{
/*
* Equivalent to:
* arm_q7_to_q15_no_shift( (q7_t*)Im_in+(i_ker_y*dim_im_in+i_ker_x)*3, pBuffer, 3);
*/
const q7_t *pPixel = Im_in + (i_ker_y * dim_im_in + i_ker_x) * 3;
q31_t buf = arm_nn_read_q7x4(pPixel);
union arm_nnword top;
union arm_nnword bottom;
top.word = __SXTB16(buf);
bottom.word = __SXTB16(__ROR(buf, 8));
#ifndef ARM_MATH_BIG_ENDIAN
/*
* little-endian, | omit | 3rd | 2nd | 1st |
* MSB LSB
* top | 3rd | 1st |; bottom | omit | 2nd |
*
* version 1, need to swap 2nd and 3rd weight
* *__SIMD32(pBuffer) = top.word;
* *(pBuffer+2) = bottom.half_words[0];
*
* version 2, no weight shuffling required
*/
*pBuffer++ = top.half_words[0];
int32_t packed_word = __PKHBT(bottom.word, top.word, 0);
arm_memcpy_q7((q7_t *)pBuffer, (q7_t *)&packed_word, 4);
#else
/*
* big-endian, | 1st | 2nd | 3rd | omit |
* MSB LSB
* top | 2nd | omit |; bottom | 1st | 3rd |
*
* version 1, need to swap 2nd and 3rd weight
* *__SIMD32(pBuffer) = bottom.word;
* *(pBuffer+2) = top.half_words[1];
*
* version 2, no weight shuffling required
*/
*pBuffer++ = bottom.half_words[0];
int32_t packed_word = __PKHTB(top.word, bottom.word, 0);
arm_memcpy_q7((q7_t *)pBuffer, (q7_t *)&packed_word, 4);
#endif
pBuffer += 2;
}
}
}
if (pBuffer == bufferA + 2 * 3 * dim_kernel * dim_kernel)
{
pOut = arm_nn_mat_mult_kernel_q7_q15(
wt, bufferA, ch_im_out, 3 * dim_kernel * dim_kernel, bias_shift, out_shift, bias, pOut);
/* counter reset */
pBuffer = bufferA;
}
}
}
/* left-over because odd number of output pixels */
if (pBuffer != bufferA)
{
const q7_t *pA = wt;
int i;
for (i = 0; i < ch_im_out; i++)
{
q31_t sum = ((q31_t)bias[i] << bias_shift) + NN_ROUND(out_shift);
q15_t *pB = bufferA;
/* basically each time it process 4 entries */
uint16_t colCnt = 3 * dim_kernel * dim_kernel >> 2;
while (colCnt)
{
q31_t inA1, inA2;
q31_t inB1, inB2;
pA = read_and_pad(pA, &inA1, &inA2);
inB1 = arm_nn_read_q15x2_ia((const q15_t **)&pB);
sum = __SMLAD(inA1, inB1, sum);
inB2 = arm_nn_read_q15x2_ia((const q15_t **)&pB);
sum = __SMLAD(inA2, inB2, sum);
colCnt--;
}
colCnt = 3 * dim_kernel * dim_kernel & 0x3;
while (colCnt)
{
q7_t inA1 = *pA++;
q15_t inB1 = *pB++;
sum += inA1 * inB1;
colCnt--;
}
*pOut++ = (q7_t)__SSAT((sum >> out_shift), 8);
}
}
#else
(void)bufferA;
/* Run the following code as reference implementation for Cortex-M0 and Cortex-M3 */
int i, j, k, l, m, n;
int conv_out;
int in_row, in_col;
// check if number of input channels is 3
if (ch_im_in != 3)
{
return ARM_MATH_SIZE_MISMATCH;
}
for (i = 0; i < ch_im_out; i++)
{
for (j = 0; j < dim_im_out; j++)
{
for (k = 0; k < dim_im_out; k++)
{
conv_out = (bias[i] << bias_shift) + NN_ROUND(out_shift);
for (m = 0; m < dim_kernel; m++)
{
for (n = 0; n < dim_kernel; n++)
{
/* if-for implementation */
in_row = stride * j + m - padding;
in_col = stride * k + n - padding;
if (in_row >= 0 && in_col >= 0 && in_row < dim_im_in && in_col < dim_im_in)
{
for (l = 0; l < ch_im_in; l++)
{
conv_out += Im_in[(in_row * dim_im_in + in_col) * ch_im_in + l] *
wt[i * ch_im_in * dim_kernel * dim_kernel + (m * dim_kernel + n) * ch_im_in + l];
}
}
}
}
Im_out[i + (j * dim_im_out + k) * ch_im_out] = (q7_t)__SSAT((conv_out >> out_shift), 8);
}
}
}
#endif /* ARM_MATH_DSP */
/* Return to application */
return (ARM_MATH_SUCCESS);
}
/**
* @} end of NNConv group
*/
|
378792.c | /*
* Copyright 2001-2020 The OpenSSL Project Authors. All Rights Reserved.
* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
*
* Licensed under the OpenSSL license (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#include "internal/nelem.h"
#include "testutil.h"
#ifndef OPENSSL_NO_EC
# include <openssl/ec.h>
# ifndef OPENSSL_NO_ENGINE
# include <openssl/engine.h>
# endif
# include <openssl/err.h>
# include <openssl/obj_mac.h>
# include <openssl/objects.h>
# include <openssl/rand.h>
# include <openssl/bn.h>
# include <openssl/opensslconf.h>
static size_t crv_len = 0;
static EC_builtin_curve *curves = NULL;
/* test multiplication with group order, long and negative scalars */
static int group_order_tests(EC_GROUP *group)
{
BIGNUM *n1 = NULL, *n2 = NULL, *order = NULL;
EC_POINT *P = NULL, *Q = NULL, *R = NULL, *S = NULL;
const EC_POINT *G = NULL;
BN_CTX *ctx = NULL;
int i = 0, r = 0;
if (!TEST_ptr(n1 = BN_new())
|| !TEST_ptr(n2 = BN_new())
|| !TEST_ptr(order = BN_new())
|| !TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(G = EC_GROUP_get0_generator(group))
|| !TEST_ptr(P = EC_POINT_new(group))
|| !TEST_ptr(Q = EC_POINT_new(group))
|| !TEST_ptr(R = EC_POINT_new(group))
|| !TEST_ptr(S = EC_POINT_new(group)))
goto err;
if (!TEST_true(EC_GROUP_get_order(group, order, ctx))
|| !TEST_true(EC_POINT_mul(group, Q, order, NULL, NULL, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, Q))
|| !TEST_true(EC_GROUP_precompute_mult(group, ctx))
|| !TEST_true(EC_POINT_mul(group, Q, order, NULL, NULL, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, Q))
|| !TEST_true(EC_POINT_copy(P, G))
|| !TEST_true(BN_one(n1))
|| !TEST_true(EC_POINT_mul(group, Q, n1, NULL, NULL, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, ctx))
|| !TEST_true(BN_sub(n1, order, n1))
|| !TEST_true(EC_POINT_mul(group, Q, n1, NULL, NULL, ctx))
|| !TEST_true(EC_POINT_invert(group, Q, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, ctx)))
goto err;
for (i = 1; i <= 2; i++) {
const BIGNUM *scalars[6];
const EC_POINT *points[6];
if (!TEST_true(BN_set_word(n1, i))
/*
* If i == 1, P will be the predefined generator for which
* EC_GROUP_precompute_mult has set up precomputation.
*/
|| !TEST_true(EC_POINT_mul(group, P, n1, NULL, NULL, ctx))
|| (i == 1 && !TEST_int_eq(0, EC_POINT_cmp(group, P, G, ctx)))
|| !TEST_true(BN_one(n1))
/* n1 = 1 - order */
|| !TEST_true(BN_sub(n1, n1, order))
|| !TEST_true(EC_POINT_mul(group, Q, NULL, P, n1, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, ctx))
/* n2 = 1 + order */
|| !TEST_true(BN_add(n2, order, BN_value_one()))
|| !TEST_true(EC_POINT_mul(group, Q, NULL, P, n2, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, ctx))
/* n2 = (1 - order) * (1 + order) = 1 - order^2 */
|| !TEST_true(BN_mul(n2, n1, n2, ctx))
|| !TEST_true(EC_POINT_mul(group, Q, NULL, P, n2, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, ctx)))
goto err;
/* n2 = order^2 - 1 */
BN_set_negative(n2, 0);
if (!TEST_true(EC_POINT_mul(group, Q, NULL, P, n2, ctx))
/* Add P to verify the result. */
|| !TEST_true(EC_POINT_add(group, Q, Q, P, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, Q))
/* Exercise EC_POINTs_mul, including corner cases. */
|| !TEST_false(EC_POINT_is_at_infinity(group, P)))
goto err;
scalars[0] = scalars[1] = BN_value_one();
points[0] = points[1] = P;
if (!TEST_true(EC_POINTs_mul(group, R, NULL, 2, points, scalars, ctx))
|| !TEST_true(EC_POINT_dbl(group, S, points[0], ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, R, S, ctx)))
goto err;
scalars[0] = n1;
points[0] = Q; /* => infinity */
scalars[1] = n2;
points[1] = P; /* => -P */
scalars[2] = n1;
points[2] = Q; /* => infinity */
scalars[3] = n2;
points[3] = Q; /* => infinity */
scalars[4] = n1;
points[4] = P; /* => P */
scalars[5] = n2;
points[5] = Q; /* => infinity */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 6, points, scalars, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
}
r = 1;
err:
if (r == 0 && i != 0)
TEST_info(i == 1 ? "allowing precomputation" :
"without precomputation");
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(R);
EC_POINT_free(S);
BN_free(n1);
BN_free(n2);
BN_free(order);
BN_CTX_free(ctx);
return r;
}
static int prime_field_tests(void)
{
BN_CTX *ctx = NULL;
BIGNUM *p = NULL, *a = NULL, *b = NULL, *scalar3 = NULL;
EC_GROUP *group = NULL, *tmp = NULL;
EC_GROUP *P_160 = NULL, *P_192 = NULL, *P_224 = NULL,
*P_256 = NULL, *P_384 = NULL, *P_521 = NULL;
EC_POINT *P = NULL, *Q = NULL, *R = NULL;
BIGNUM *x = NULL, *y = NULL, *z = NULL, *yplusone = NULL;
const EC_POINT *points[4];
const BIGNUM *scalars[4];
unsigned char buf[100];
size_t len, r = 0;
int k;
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(p = BN_new())
|| !TEST_ptr(a = BN_new())
|| !TEST_ptr(b = BN_new())
|| !TEST_true(BN_hex2bn(&p, "17"))
|| !TEST_true(BN_hex2bn(&a, "1"))
|| !TEST_true(BN_hex2bn(&b, "1"))
/*
* applications should use EC_GROUP_new_curve_GFp so
* that the library gets to choose the EC_METHOD
*/
|| !TEST_ptr(group = EC_GROUP_new(EC_GFp_mont_method()))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_ptr(tmp = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(tmp, group)))
goto err;
EC_GROUP_free(group);
group = tmp;
tmp = NULL;
if (!TEST_true(EC_GROUP_get_curve(group, p, a, b, ctx)))
goto err;
TEST_info("Curve defined by Weierstrass equation");
TEST_note(" y^2 = x^3 + a*x + b (mod p)");
test_output_bignum("a", a);
test_output_bignum("b", b);
test_output_bignum("p", p);
buf[0] = 0;
if (!TEST_ptr(P = EC_POINT_new(group))
|| !TEST_ptr(Q = EC_POINT_new(group))
|| !TEST_ptr(R = EC_POINT_new(group))
|| !TEST_true(EC_POINT_set_to_infinity(group, P))
|| !TEST_true(EC_POINT_is_at_infinity(group, P))
|| !TEST_true(EC_POINT_oct2point(group, Q, buf, 1, ctx))
|| !TEST_true(EC_POINT_add(group, P, P, Q, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P))
|| !TEST_ptr(x = BN_new())
|| !TEST_ptr(y = BN_new())
|| !TEST_ptr(z = BN_new())
|| !TEST_ptr(yplusone = BN_new())
|| !TEST_true(BN_hex2bn(&x, "D"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, Q, x, 1, ctx)))
goto err;
if (!TEST_int_gt(EC_POINT_is_on_curve(group, Q, ctx), 0)) {
if (!TEST_true(EC_POINT_get_affine_coordinates(group, Q, x, y, ctx)))
goto err;
TEST_info("Point is not on curve");
test_output_bignum("x", x);
test_output_bignum("y", y);
goto err;
}
TEST_note("A cyclic subgroup:");
k = 100;
do {
if (!TEST_int_ne(k--, 0))
goto err;
if (EC_POINT_is_at_infinity(group, P)) {
TEST_note(" point at infinity");
} else {
if (!TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y,
ctx)))
goto err;
test_output_bignum("x", x);
test_output_bignum("y", y);
}
if (!TEST_true(EC_POINT_copy(R, P))
|| !TEST_true(EC_POINT_add(group, P, P, Q, ctx)))
goto err;
} while (!EC_POINT_is_at_infinity(group, P));
if (!TEST_true(EC_POINT_add(group, P, Q, R, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
len =
EC_POINT_point2oct(group, Q, POINT_CONVERSION_COMPRESSED, buf,
sizeof(buf), ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, compressed form:",
buf, len);
len = EC_POINT_point2oct(group, Q, POINT_CONVERSION_UNCOMPRESSED,
buf, sizeof(buf), ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, uncompressed form:",
buf, len);
len = EC_POINT_point2oct(group, Q, POINT_CONVERSION_HYBRID,
buf, sizeof(buf), ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, hybrid form:",
buf, len);
if (!TEST_true(EC_POINT_get_Jprojective_coordinates_GFp(group, R, x, y, z,
ctx)))
goto err;
TEST_info("A representation of the inverse of that generator in");
TEST_note("Jacobian projective coordinates");
test_output_bignum("x", x);
test_output_bignum("y", y);
test_output_bignum("z", z);
if (!TEST_true(EC_POINT_invert(group, P, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, R, ctx))
/*
* Curve secp160r1 (Certicom Research SEC 2 Version 1.0, section 2.4.2,
* 2000) -- not a NIST curve, but commonly used
*/
|| !TEST_true(BN_hex2bn(&p, "FFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "FFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC"))
|| !TEST_true(BN_hex2bn(&b, "1C97BEFC"
"54BD7A8B65ACF89F81D4D4ADC565FA45"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "4A96B568"
"8EF573284664698968C38BB913CBFC82"))
|| !TEST_true(BN_hex2bn(&y, "23a62855"
"3168947d59dcc912042351377ac5fb32"))
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_true(EC_POINT_set_affine_coordinates(group, P, x, y, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "0100000000"
"000000000001F4C8F927AED3CA752257"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("SEC2 curve secp160r1 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "23a62855"
"3168947d59dcc912042351377ac5fb32"))
|| !TEST_BN_eq(y, z)
|| !TEST_int_eq(EC_GROUP_get_degree(group), 160)
|| !group_order_tests(group)
|| !TEST_ptr(P_160 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_160, group))
/* Curve P-192 (FIPS PUB 186-2, App. 6) */
|| !TEST_true(BN_hex2bn(&p, "FFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "FFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC"))
|| !TEST_true(BN_hex2bn(&b, "64210519E59C80E7"
"0FA7E9AB72243049FEB8DEECC146B9B1"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "188DA80EB03090F6"
"7CBF20EB43A18800F4FF0AFD82FF1012"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x, 1, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "FFFFFFFFFFFFFFFF"
"FFFFFFFF99DEF836146BC9B1B4D22831"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("NIST curve P-192 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "07192B95FFC8DA78"
"631011ED6B24CDD573F977A11E794811"))
|| !TEST_BN_eq(y, z)
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_int_eq(EC_GROUP_get_degree(group), 192)
|| !group_order_tests(group)
|| !TEST_ptr(P_192 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_192, group))
/* Curve P-224 (FIPS PUB 186-2, App. 6) */
|| !TEST_true(BN_hex2bn(&p, "FFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFF000000000000000000000001"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "FFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE"))
|| !TEST_true(BN_hex2bn(&b, "B4050A850C04B3ABF5413256"
"5044B0B7D7BFD8BA270B39432355FFB4"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "B70E0CBD6BB4BF7F321390B9"
"4A03C1D356C21122343280D6115C1D21"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x, 0, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "FFFFFFFFFFFFFFFFFFFFFFFF"
"FFFF16A2E0B8F03E13DD29455C5C2A3D"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("NIST curve P-224 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "BD376388B5F723FB4C22DFE6"
"CD4375A05A07476444D5819985007E34"))
|| !TEST_BN_eq(y, z)
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_int_eq(EC_GROUP_get_degree(group), 224)
|| !group_order_tests(group)
|| !TEST_ptr(P_224 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_224, group))
/* Curve P-256 (FIPS PUB 186-2, App. 6) */
|| !TEST_true(BN_hex2bn(&p, "FFFFFFFF000000010000000000000000"
"00000000FFFFFFFFFFFFFFFFFFFFFFFF"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "FFFFFFFF000000010000000000000000"
"00000000FFFFFFFFFFFFFFFFFFFFFFFC"))
|| !TEST_true(BN_hex2bn(&b, "5AC635D8AA3A93E7B3EBBD55769886BC"
"651D06B0CC53B0F63BCE3C3E27D2604B"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "6B17D1F2E12C4247F8BCE6E563A440F2"
"77037D812DEB33A0F4A13945D898C296"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x, 1, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "FFFFFFFF00000000FFFFFFFFFFFFFFFF"
"BCE6FAADA7179E84F3B9CAC2FC632551"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("NIST curve P-256 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "4FE342E2FE1A7F9B8EE7EB4A7C0F9E16"
"2BCE33576B315ECECBB6406837BF51F5"))
|| !TEST_BN_eq(y, z)
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_int_eq(EC_GROUP_get_degree(group), 256)
|| !group_order_tests(group)
|| !TEST_ptr(P_256 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_256, group))
/* Curve P-384 (FIPS PUB 186-2, App. 6) */
|| !TEST_true(BN_hex2bn(&p, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE"
"FFFFFFFF0000000000000000FFFFFFFF"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE"
"FFFFFFFF0000000000000000FFFFFFFC"))
|| !TEST_true(BN_hex2bn(&b, "B3312FA7E23EE7E4988E056BE3F82D19"
"181D9C6EFE8141120314088F5013875A"
"C656398D8A2ED19D2A85C8EDD3EC2AEF"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "AA87CA22BE8B05378EB1C71EF320AD74"
"6E1D3B628BA79B9859F741E082542A38"
"5502F25DBF55296C3A545E3872760AB7"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x, 1, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFC7634D81F4372DDF"
"581A0DB248B0A77AECEC196ACCC52973"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("NIST curve P-384 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "3617DE4A96262C6F5D9E98BF9292DC29"
"F8F41DBD289A147CE9DA3113B5F0B8C0"
"0A60B1CE1D7E819D7A431D7C90EA0E5F"))
|| !TEST_BN_eq(y, z)
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_int_eq(EC_GROUP_get_degree(group), 384)
|| !group_order_tests(group)
|| !TEST_ptr(P_384 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_384, group))
/* Curve P-521 (FIPS PUB 186-2, App. 6) */
|| !TEST_true(BN_hex2bn(&p, "1FF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, "1FF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC"))
|| !TEST_true(BN_hex2bn(&b, "051"
"953EB9618E1C9A1F929A21A0B68540EE"
"A2DA725B99B315F3B8B489918EF109E1"
"56193951EC7E937B1652C0BD3BB1BF07"
"3573DF883D2C34F1EF451FD46B503F00"))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_true(BN_hex2bn(&x, "C6"
"858E06B70404E9CD9E3ECB662395B442"
"9C648139053FB521F828AF606B4D3DBA"
"A14B5E77EFE75928FE1DC127A2FFA8DE"
"3348B3C1856A429BF97E7E31C2E5BD66"))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x, 0, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, "1FF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA"
"51868783BF2F966B7FCC0148F709A5D0"
"3BB5C9B8899C47AEBB6FB71E91386409"))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, BN_value_one()))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("NIST curve P-521 -- Generator");
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, "118"
"39296A789A3BC0045C8A5FB42C7D1BD9"
"98F54449579B446817AFBD17273E662C"
"97EE72995EF42640C550B9013FAD0761"
"353C7086A272C24088BE94769FD16650"))
|| !TEST_BN_eq(y, z)
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone,
ctx))
|| !TEST_int_eq(EC_GROUP_get_degree(group), 521)
|| !group_order_tests(group)
|| !TEST_ptr(P_521 = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(P_521, group))
/* more tests using the last curve */
/* Restore the point that got mangled in the (x, y + 1) test. */
|| !TEST_true(EC_POINT_set_affine_coordinates(group, P, x, y, ctx))
|| !TEST_true(EC_POINT_copy(Q, P))
|| !TEST_false(EC_POINT_is_at_infinity(group, Q))
|| !TEST_true(EC_POINT_dbl(group, P, P, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(EC_POINT_invert(group, Q, ctx)) /* P = -2Q */
|| !TEST_true(EC_POINT_add(group, R, P, Q, ctx))
|| !TEST_true(EC_POINT_add(group, R, R, Q, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, R)) /* R = P + 2Q */
|| !TEST_false(EC_POINT_is_at_infinity(group, Q)))
goto err;
points[0] = Q;
points[1] = Q;
points[2] = Q;
points[3] = Q;
if (!TEST_true(EC_GROUP_get_order(group, z, ctx))
|| !TEST_true(BN_add(y, z, BN_value_one()))
|| !TEST_BN_even(y)
|| !TEST_true(BN_rshift1(y, y)))
goto err;
scalars[0] = y; /* (group order + 1)/2, so y*Q + y*Q = Q */
scalars[1] = y;
TEST_note("combined multiplication ...");
/* z is still the group order */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 2, points, scalars, ctx))
|| !TEST_true(EC_POINTs_mul(group, R, z, 2, points, scalars, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, R, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, R, Q, ctx))
|| !TEST_true(BN_rand(y, BN_num_bits(y), 0, 0))
|| !TEST_true(BN_add(z, z, y)))
goto err;
BN_set_negative(z, 1);
scalars[0] = y;
scalars[1] = z; /* z = -(order + y) */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 2, points, scalars, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P))
|| !TEST_true(BN_rand(x, BN_num_bits(y) - 1, 0, 0))
|| !TEST_true(BN_add(z, x, y)))
goto err;
BN_set_negative(z, 1);
scalars[0] = x;
scalars[1] = y;
scalars[2] = z; /* z = -(x+y) */
if (!TEST_ptr(scalar3 = BN_new()))
goto err;
BN_zero(scalar3);
scalars[3] = scalar3;
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 4, points, scalars, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
TEST_note(" ok\n");
r = 1;
err:
BN_CTX_free(ctx);
BN_free(p);
BN_free(a);
BN_free(b);
EC_GROUP_free(group);
EC_GROUP_free(tmp);
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(R);
BN_free(x);
BN_free(y);
BN_free(z);
BN_free(yplusone);
BN_free(scalar3);
EC_GROUP_free(P_160);
EC_GROUP_free(P_192);
EC_GROUP_free(P_224);
EC_GROUP_free(P_256);
EC_GROUP_free(P_384);
EC_GROUP_free(P_521);
return r;
}
# ifndef OPENSSL_NO_EC2M
static struct c2_curve_test {
const char *name;
const char *p;
const char *a;
const char *b;
const char *x;
const char *y;
int ybit;
const char *order;
const char *cof;
int degree;
} char2_curve_tests[] = {
/* Curve K-163 (FIPS PUB 186-2, App. 6) */
{
"NIST curve K-163",
"0800000000000000000000000000000000000000C9",
"1",
"1",
"02FE13C0537BBC11ACAA07D793DE4E6D5E5C94EEE8",
"0289070FB05D38FF58321F2E800536D538CCDAA3D9",
1, "04000000000000000000020108A2E0CC0D99F8A5EF", "2", 163
},
/* Curve B-163 (FIPS PUB 186-2, App. 6) */
{
"NIST curve B-163",
"0800000000000000000000000000000000000000C9",
"1",
"020A601907B8C953CA1481EB10512F78744A3205FD",
"03F0EBA16286A2D57EA0991168D4994637E8343E36",
"00D51FBC6C71A0094FA2CDD545B11C5C0C797324F1",
1, "040000000000000000000292FE77E70C12A4234C33", "2", 163
},
/* Curve K-233 (FIPS PUB 186-2, App. 6) */
{
"NIST curve K-233",
"020000000000000000000000000000000000000004000000000000000001",
"0",
"1",
"017232BA853A7E731AF129F22FF4149563A419C26BF50A4C9D6EEFAD6126",
"01DB537DECE819B7F70F555A67C427A8CD9BF18AEB9B56E0C11056FAE6A3",
0,
"008000000000000000000000000000069D5BB915BCD46EFB1AD5F173ABDF",
"4", 233
},
/* Curve B-233 (FIPS PUB 186-2, App. 6) */
{
"NIST curve B-233",
"020000000000000000000000000000000000000004000000000000000001",
"000000000000000000000000000000000000000000000000000000000001",
"0066647EDE6C332C7F8C0923BB58213B333B20E9CE4281FE115F7D8F90AD",
"00FAC9DFCBAC8313BB2139F1BB755FEF65BC391F8B36F8F8EB7371FD558B",
"01006A08A41903350678E58528BEBF8A0BEFF867A7CA36716F7E01F81052",
1,
"01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7",
"2", 233
},
/* Curve K-283 (FIPS PUB 186-2, App. 6) */
{
"NIST curve K-283",
"08000000"
"00000000000000000000000000000000000000000000000000000000000010A1",
"0",
"1",
"0503213F"
"78CA44883F1A3B8162F188E553CD265F23C1567A16876913B0C2AC2458492836",
"01CCDA38"
"0F1C9E318D90F95D07E5426FE87E45C0E8184698E45962364E34116177DD2259",
0,
"01FFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFE9AE2ED07577265DFF7F94451E061E163C61",
"4", 283
},
/* Curve B-283 (FIPS PUB 186-2, App. 6) */
{
"NIST curve B-283",
"08000000"
"00000000000000000000000000000000000000000000000000000000000010A1",
"00000000"
"0000000000000000000000000000000000000000000000000000000000000001",
"027B680A"
"C8B8596DA5A4AF8A19A0303FCA97FD7645309FA2A581485AF6263E313B79A2F5",
"05F93925"
"8DB7DD90E1934F8C70B0DFEC2EED25B8557EAC9C80E2E198F8CDBECD86B12053",
"03676854"
"FE24141CB98FE6D4B20D02B4516FF702350EDDB0826779C813F0DF45BE8112F4",
1,
"03FFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFEF90399660FC938A90165B042A7CEFADB307",
"2", 283
},
/* Curve K-409 (FIPS PUB 186-2, App. 6) */
{
"NIST curve K-409",
"0200000000000000000000000000000000000000"
"0000000000000000000000000000000000000000008000000000000000000001",
"0",
"1",
"0060F05F658F49C1AD3AB1890F7184210EFD0987"
"E307C84C27ACCFB8F9F67CC2C460189EB5AAAA62EE222EB1B35540CFE9023746",
"01E369050B7C4E42ACBA1DACBF04299C3460782F"
"918EA427E6325165E9EA10E3DA5F6C42E9C55215AA9CA27A5863EC48D8E0286B",
1,
"007FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
"FFFFFFFFFFFFFE5F83B2D4EA20400EC4557D5ED3E3E7CA5B4B5C83B8E01E5FCF",
"4", 409
},
/* Curve B-409 (FIPS PUB 186-2, App. 6) */
{
"NIST curve B-409",
"0200000000000000000000000000000000000000"
"0000000000000000000000000000000000000000008000000000000000000001",
"0000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000000000000001",
"0021A5C2C8EE9FEB5C4B9A753B7B476B7FD6422E"
"F1F3DD674761FA99D6AC27C8A9A197B272822F6CD57A55AA4F50AE317B13545F",
"015D4860D088DDB3496B0C6064756260441CDE4A"
"F1771D4DB01FFE5B34E59703DC255A868A1180515603AEAB60794E54BB7996A7",
"0061B1CFAB6BE5F32BBFA78324ED106A7636B9C5"
"A7BD198D0158AA4F5488D08F38514F1FDF4B4F40D2181B3681C364BA0273C706",
1,
"0100000000000000000000000000000000000000"
"00000000000001E2AAD6A612F33307BE5FA47C3C9E052F838164CD37D9A21173",
"2", 409
},
/* Curve K-571 (FIPS PUB 186-2, App. 6) */
{
"NIST curve K-571",
"800000000000000"
"0000000000000000000000000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000000000000425",
"0",
"1",
"026EB7A859923FBC"
"82189631F8103FE4AC9CA2970012D5D46024804801841CA44370958493B205E6"
"47DA304DB4CEB08CBBD1BA39494776FB988B47174DCA88C7E2945283A01C8972",
"0349DC807F4FBF37"
"4F4AEADE3BCA95314DD58CEC9F307A54FFC61EFC006D8A2C9D4979C0AC44AEA7"
"4FBEBBB9F772AEDCB620B01A7BA7AF1B320430C8591984F601CD4C143EF1C7A3",
0,
"0200000000000000"
"00000000000000000000000000000000000000000000000000000000131850E1"
"F19A63E4B391A8DB917F4138B630D84BE5D639381E91DEB45CFE778F637C1001",
"4", 571
},
/* Curve B-571 (FIPS PUB 186-2, App. 6) */
{
"NIST curve B-571",
"800000000000000"
"0000000000000000000000000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000000000000425",
"0000000000000000"
"0000000000000000000000000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000000000000001",
"02F40E7E2221F295"
"DE297117B7F3D62F5C6A97FFCB8CEFF1CD6BA8CE4A9A18AD84FFABBD8EFA5933"
"2BE7AD6756A66E294AFD185A78FF12AA520E4DE739BACA0C7FFEFF7F2955727A",
"0303001D34B85629"
"6C16C0D40D3CD7750A93D1D2955FA80AA5F40FC8DB7B2ABDBDE53950F4C0D293"
"CDD711A35B67FB1499AE60038614F1394ABFA3B4C850D927E1E7769C8EEC2D19",
"037BF27342DA639B"
"6DCCFFFEB73D69D78C6C27A6009CBBCA1980F8533921E8A684423E43BAB08A57"
"6291AF8F461BB2A8B3531D2F0485C19B16E2F1516E23DD3C1A4827AF1B8AC15B",
1,
"03FFFFFFFFFFFFFF"
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE661CE18"
"FF55987308059B186823851EC7DD9CA1161DE93D5174D66E8382E9BB2FE84E47",
"2", 571
}
};
static int char2_curve_test(int n)
{
int r = 0;
BN_CTX *ctx = NULL;
BIGNUM *p = NULL, *a = NULL, *b = NULL;
BIGNUM *x = NULL, *y = NULL, *z = NULL, *cof = NULL, *yplusone = NULL;
EC_GROUP *group = NULL, *variable = NULL;
EC_POINT *P = NULL, *Q = NULL, *R = NULL;
const EC_POINT *points[3];
const BIGNUM *scalars[3];
struct c2_curve_test *const test = char2_curve_tests + n;
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(p = BN_new())
|| !TEST_ptr(a = BN_new())
|| !TEST_ptr(b = BN_new())
|| !TEST_ptr(x = BN_new())
|| !TEST_ptr(y = BN_new())
|| !TEST_ptr(z = BN_new())
|| !TEST_ptr(yplusone = BN_new())
|| !TEST_true(BN_hex2bn(&p, test->p))
|| !TEST_true(BN_hex2bn(&a, test->a))
|| !TEST_true(BN_hex2bn(&b, test->b))
|| !TEST_true(group = EC_GROUP_new(EC_GF2m_simple_method()))
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_ptr(P = EC_POINT_new(group))
|| !TEST_ptr(Q = EC_POINT_new(group))
|| !TEST_ptr(R = EC_POINT_new(group))
|| !TEST_true(BN_hex2bn(&x, test->x))
|| !TEST_true(BN_hex2bn(&y, test->y))
|| !TEST_true(BN_add(yplusone, y, BN_value_one())))
goto err;
/* Change test based on whether binary point compression is enabled or not. */
# ifdef OPENSSL_EC_BIN_PT_COMP
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
if (!TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone, ctx))
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, P, x,
test->y_bit,
ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, test->order))
|| !TEST_true(BN_hex2bn(&cof, test->cof))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, cof))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y, ctx)))
goto err;
TEST_info("%s -- Generator", test->name);
test_output_bignum("x", x);
test_output_bignum("y", y);
/* G_y value taken from the standard: */
if (!TEST_true(BN_hex2bn(&z, test->y))
|| !TEST_BN_eq(y, z))
goto err;
# else
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
if (!TEST_false(EC_POINT_set_affine_coordinates(group, P, x, yplusone, ctx))
|| !TEST_true(EC_POINT_set_affine_coordinates(group, P, x, y, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(BN_hex2bn(&z, test->order))
|| !TEST_true(BN_hex2bn(&cof, test->cof))
|| !TEST_true(EC_GROUP_set_generator(group, P, z, cof)))
goto err;
TEST_info("%s -- Generator:", test->name);
test_output_bignum("x", x);
test_output_bignum("y", y);
# endif
if (!TEST_int_eq(EC_GROUP_get_degree(group), test->degree)
|| !group_order_tests(group)
|| !TEST_ptr(variable = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(variable, group)))
goto err;
/* more tests using the last curve */
if (n == OSSL_NELEM(char2_curve_tests) - 1) {
if (!TEST_true(EC_POINT_set_affine_coordinates(group, P, x, y, ctx))
|| !TEST_true(EC_POINT_copy(Q, P))
|| !TEST_false(EC_POINT_is_at_infinity(group, Q))
|| !TEST_true(EC_POINT_dbl(group, P, P, ctx))
|| !TEST_int_gt(EC_POINT_is_on_curve(group, P, ctx), 0)
|| !TEST_true(EC_POINT_invert(group, Q, ctx)) /* P = -2Q */
|| !TEST_true(EC_POINT_add(group, R, P, Q, ctx))
|| !TEST_true(EC_POINT_add(group, R, R, Q, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, R)) /* R = P + 2Q */
|| !TEST_false(EC_POINT_is_at_infinity(group, Q)))
goto err;
points[0] = Q;
points[1] = Q;
points[2] = Q;
if (!TEST_true(BN_add(y, z, BN_value_one()))
|| !TEST_BN_even(y)
|| !TEST_true(BN_rshift1(y, y)))
goto err;
scalars[0] = y; /* (group order + 1)/2, so y*Q + y*Q = Q */
scalars[1] = y;
TEST_note("combined multiplication ...");
/* z is still the group order */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 2, points, scalars, ctx))
|| !TEST_true(EC_POINTs_mul(group, R, z, 2, points, scalars, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, R, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, R, Q, ctx)))
goto err;
if (!TEST_true(BN_rand(y, BN_num_bits(y), 0, 0))
|| !TEST_true(BN_add(z, z, y)))
goto err;
BN_set_negative(z, 1);
scalars[0] = y;
scalars[1] = z; /* z = -(order + y) */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 2, points, scalars, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
if (!TEST_true(BN_rand(x, BN_num_bits(y) - 1, 0, 0))
|| !TEST_true(BN_add(z, x, y)))
goto err;
BN_set_negative(z, 1);
scalars[0] = x;
scalars[1] = y;
scalars[2] = z; /* z = -(x+y) */
if (!TEST_true(EC_POINTs_mul(group, P, NULL, 3, points, scalars, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;;
}
r = 1;
err:
BN_CTX_free(ctx);
BN_free(p);
BN_free(a);
BN_free(b);
BN_free(x);
BN_free(y);
BN_free(z);
BN_free(yplusone);
BN_free(cof);
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(R);
EC_GROUP_free(group);
EC_GROUP_free(variable);
return r;
}
static int char2_field_tests(void)
{
BN_CTX *ctx = NULL;
BIGNUM *p = NULL, *a = NULL, *b = NULL;
EC_GROUP *group = NULL, *tmp = NULL;
EC_POINT *P = NULL, *Q = NULL, *R = NULL;
BIGNUM *x = NULL, *y = NULL, *z = NULL, *cof = NULL, *yplusone = NULL;
unsigned char buf[100];
size_t len;
int k, r = 0;
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(p = BN_new())
|| !TEST_ptr(a = BN_new())
|| !TEST_ptr(b = BN_new())
|| !TEST_true(BN_hex2bn(&p, "13"))
|| !TEST_true(BN_hex2bn(&a, "3"))
|| !TEST_true(BN_hex2bn(&b, "1")))
goto err;
group = EC_GROUP_new(EC_GF2m_simple_method()); /* applications should use
* EC_GROUP_new_curve_GF2m
* so that the library gets
* to choose the EC_METHOD */
if (!TEST_ptr(group)
|| !TEST_true(EC_GROUP_set_curve(group, p, a, b, ctx))
|| !TEST_ptr(tmp = EC_GROUP_new(EC_GROUP_method_of(group)))
|| !TEST_true(EC_GROUP_copy(tmp, group)))
goto err;
EC_GROUP_free(group);
group = tmp;
tmp = NULL;
if (!TEST_true(EC_GROUP_get_curve(group, p, a, b, ctx)))
goto err;
TEST_info("Curve defined by Weierstrass equation");
TEST_note(" y^2 + x*y = x^3 + a*x^2 + b (mod p)");
test_output_bignum("a", a);
test_output_bignum("b", b);
test_output_bignum("p", p);
if (!TEST_ptr(P = EC_POINT_new(group))
|| !TEST_ptr(Q = EC_POINT_new(group))
|| !TEST_ptr(R = EC_POINT_new(group))
|| !TEST_true(EC_POINT_set_to_infinity(group, P))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
buf[0] = 0;
if (!TEST_true(EC_POINT_oct2point(group, Q, buf, 1, ctx))
|| !TEST_true(EC_POINT_add(group, P, P, Q, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P))
|| !TEST_ptr(x = BN_new())
|| !TEST_ptr(y = BN_new())
|| !TEST_ptr(z = BN_new())
|| !TEST_ptr(cof = BN_new())
|| !TEST_ptr(yplusone = BN_new())
|| !TEST_true(BN_hex2bn(&x, "6"))
/* Change test based on whether binary point compression is enabled or not. */
# ifdef OPENSSL_EC_BIN_PT_COMP
|| !TEST_true(EC_POINT_set_compressed_coordinates(group, Q, x, 1, ctx))
# else
|| !TEST_true(BN_hex2bn(&y, "8"))
|| !TEST_true(EC_POINT_set_affine_coordinates(group, Q, x, y, ctx))
# endif
)
goto err;
if (!TEST_int_gt(EC_POINT_is_on_curve(group, Q, ctx), 0)) {
/* Change test based on whether binary point compression is enabled or not. */
# ifdef OPENSSL_EC_BIN_PT_COMP
if (!TEST_true(EC_POINT_get_affine_coordinates(group, Q, x, y, ctx)))
goto err;
# endif
TEST_info("Point is not on curve");
test_output_bignum("x", x);
test_output_bignum("y", y);
goto err;
}
TEST_note("A cyclic subgroup:");
k = 100;
do {
if (!TEST_int_ne(k--, 0))
goto err;
if (EC_POINT_is_at_infinity(group, P))
TEST_note(" point at infinity");
else {
if (!TEST_true(EC_POINT_get_affine_coordinates(group, P, x, y,
ctx)))
goto err;
test_output_bignum("x", x);
test_output_bignum("y", y);
}
if (!TEST_true(EC_POINT_copy(R, P))
|| !TEST_true(EC_POINT_add(group, P, P, Q, ctx)))
goto err;
}
while (!EC_POINT_is_at_infinity(group, P));
if (!TEST_true(EC_POINT_add(group, P, Q, R, ctx))
|| !TEST_true(EC_POINT_is_at_infinity(group, P)))
goto err;
/* Change test based on whether binary point compression is enabled or not. */
# ifdef OPENSSL_EC_BIN_PT_COMP
len = EC_POINT_point2oct(group, Q, POINT_CONVERSION_COMPRESSED,
buf, sizeof(buf), ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, compressed form:",
buf, len);
# endif
len = EC_POINT_point2oct(group, Q, POINT_CONVERSION_UNCOMPRESSED,
buf, sizeof(buf), ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, uncompressed form:",
buf, len);
/* Change test based on whether binary point compression is enabled or not. */
# ifdef OPENSSL_EC_BIN_PT_COMP
len =
EC_POINT_point2oct(group, Q, POINT_CONVERSION_HYBRID, buf, sizeof(buf),
ctx);
if (!TEST_size_t_ne(len, 0)
|| !TEST_true(EC_POINT_oct2point(group, P, buf, len, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, Q, ctx)))
goto err;
test_output_memory("Generator as octet string, hybrid form:",
buf, len);
# endif
if (!TEST_true(EC_POINT_invert(group, P, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, P, R, ctx)))
goto err;
TEST_note("\n");
r = 1;
err:
BN_CTX_free(ctx);
BN_free(p);
BN_free(a);
BN_free(b);
EC_GROUP_free(group);
EC_GROUP_free(tmp);
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(R);
BN_free(x);
BN_free(y);
BN_free(z);
BN_free(cof);
BN_free(yplusone);
return r;
}
static int hybrid_point_encoding_test(void)
{
BIGNUM *x = NULL, *y = NULL;
EC_GROUP *group = NULL;
EC_POINT *point = NULL;
unsigned char *buf = NULL;
size_t len;
int r = 0;
if (!TEST_true(BN_dec2bn(&x, "0"))
|| !TEST_true(BN_dec2bn(&y, "1"))
|| !TEST_ptr(group = EC_GROUP_new_by_curve_name(NID_sect571k1))
|| !TEST_ptr(point = EC_POINT_new(group))
|| !TEST_true(EC_POINT_set_affine_coordinates(group, point, x, y, NULL))
|| !TEST_size_t_ne(0, (len = EC_POINT_point2oct(group,
point,
POINT_CONVERSION_HYBRID,
NULL,
0,
NULL)))
|| !TEST_ptr(buf = OPENSSL_malloc(len))
|| !TEST_size_t_eq(len, EC_POINT_point2oct(group,
point,
POINT_CONVERSION_HYBRID,
buf,
len,
NULL)))
goto err;
r = 1;
/* buf contains a valid hybrid point, check that we can decode it. */
if (!TEST_true(EC_POINT_oct2point(group, point, buf, len, NULL)))
r = 0;
/* Flip the y_bit and verify that the invalid encoding is rejected. */
buf[0] ^= 1;
if (!TEST_false(EC_POINT_oct2point(group, point, buf, len, NULL)))
r = 0;
err:
BN_free(x);
BN_free(y);
EC_GROUP_free(group);
EC_POINT_free(point);
OPENSSL_free(buf);
return r;
}
#endif
static int internal_curve_test(int n)
{
EC_GROUP *group = NULL;
int nid = curves[n].nid;
if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))) {
TEST_info("EC_GROUP_new_curve_name() failed with curve %s\n",
OBJ_nid2sn(nid));
return 0;
}
if (!TEST_true(EC_GROUP_check(group, NULL))) {
TEST_info("EC_GROUP_check() failed with curve %s\n", OBJ_nid2sn(nid));
EC_GROUP_free(group);
return 0;
}
EC_GROUP_free(group);
return 1;
}
static int internal_curve_test_method(int n)
{
int r, nid = curves[n].nid;
EC_GROUP *group;
if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))) {
TEST_info("Curve %s failed\n", OBJ_nid2sn(nid));
return 0;
}
r = group_order_tests(group);
EC_GROUP_free(group);
return r;
}
# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
/*
* nistp_test_params contains magic numbers for testing our optimized
* implementations of several NIST curves with characteristic > 3.
*/
struct nistp_test_params {
const EC_METHOD *(*meth) (void);
int degree;
/*
* Qx, Qy and D are taken from
* http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/ECDSA_Prime.pdf
* Otherwise, values are standard curve parameters from FIPS 180-3
*/
const char *p, *a, *b, *Qx, *Qy, *Gx, *Gy, *order, *d;
};
static const struct nistp_test_params nistp_tests_params[] = {
{
/* P-224 */
EC_GFp_nistp224_method,
224,
/* p */
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001",
/* a */
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE",
/* b */
"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4",
/* Qx */
"E84FB0B8E7000CB657D7973CF6B42ED78B301674276DF744AF130B3E",
/* Qy */
"4376675C6FC5612C21A0FF2D2A89D2987DF7A2BC52183B5982298555",
/* Gx */
"B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21",
/* Gy */
"BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34",
/* order */
"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D",
/* d */
"3F0C488E987C80BE0FEE521F8D90BE6034EC69AE11CA72AA777481E8",
},
{
/* P-256 */
EC_GFp_nistp256_method,
256,
/* p */
"ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
/* a */
"ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
/* b */
"5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
/* Qx */
"b7e08afdfe94bad3f1dc8c734798ba1c62b3a0ad1e9ea2a38201cd0889bc7a19",
/* Qy */
"3603f747959dbf7a4bb226e41928729063adc7ae43529e61b563bbc606cc5e09",
/* Gx */
"6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
/* Gy */
"4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
/* order */
"ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
/* d */
"c477f9f65c22cce20657faa5b2d1d8122336f851a508a1ed04e479c34985bf96",
},
{
/* P-521 */
EC_GFp_nistp521_method,
521,
/* p */
"1ff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
/* a */
"1ff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc",
/* b */
"051"
"953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e1"
"56193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00",
/* Qx */
"0098"
"e91eef9a68452822309c52fab453f5f117c1da8ed796b255e9ab8f6410cca16e"
"59df403a6bdc6ca467a37056b1e54b3005d8ac030decfeb68df18b171885d5c4",
/* Qy */
"0164"
"350c321aecfc1cca1ba4364c9b15656150b4b78d6a48d7d28e7f31985ef17be8"
"554376b72900712c4b83ad668327231526e313f5f092999a4632fd50d946bc2e",
/* Gx */
"c6"
"858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dba"
"a14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66",
/* Gy */
"118"
"39296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c"
"97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650",
/* order */
"1ff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa"
"51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409",
/* d */
"0100"
"085f47b8e1b8b11b7eb33028c0b2888e304bfc98501955b45bba1478dc184eee"
"df09b86a5f7c21994406072787205e69a63709fe35aa93ba333514b24f961722",
},
};
static int nistp_single_test(int idx)
{
const struct nistp_test_params *test = nistp_tests_params + idx;
BN_CTX *ctx = NULL;
BIGNUM *p = NULL, *a = NULL, *b = NULL, *x = NULL, *y = NULL;
BIGNUM *n = NULL, *m = NULL, *order = NULL, *yplusone = NULL;
EC_GROUP *NISTP = NULL;
EC_POINT *G = NULL, *P = NULL, *Q = NULL, *Q_CHECK = NULL;
int r = 0;
TEST_note("NIST curve P-%d (optimised implementation):",
test->degree);
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(p = BN_new())
|| !TEST_ptr(a = BN_new())
|| !TEST_ptr(b = BN_new())
|| !TEST_ptr(x = BN_new())
|| !TEST_ptr(y = BN_new())
|| !TEST_ptr(m = BN_new())
|| !TEST_ptr(n = BN_new())
|| !TEST_ptr(order = BN_new())
|| !TEST_ptr(yplusone = BN_new())
|| !TEST_ptr(NISTP = EC_GROUP_new(test->meth()))
|| !TEST_true(BN_hex2bn(&p, test->p))
|| !TEST_int_eq(1, BN_is_prime_ex(p, BN_prime_checks, ctx, NULL))
|| !TEST_true(BN_hex2bn(&a, test->a))
|| !TEST_true(BN_hex2bn(&b, test->b))
|| !TEST_true(EC_GROUP_set_curve(NISTP, p, a, b, ctx))
|| !TEST_ptr(G = EC_POINT_new(NISTP))
|| !TEST_ptr(P = EC_POINT_new(NISTP))
|| !TEST_ptr(Q = EC_POINT_new(NISTP))
|| !TEST_ptr(Q_CHECK = EC_POINT_new(NISTP))
|| !TEST_true(BN_hex2bn(&x, test->Qx))
|| !TEST_true(BN_hex2bn(&y, test->Qy))
|| !TEST_true(BN_add(yplusone, y, BN_value_one()))
/*
* When (x, y) is on the curve, (x, y + 1) is, as it happens, not,
* and therefore setting the coordinates should fail.
*/
|| !TEST_false(EC_POINT_set_affine_coordinates(NISTP, Q_CHECK, x,
yplusone, ctx))
|| !TEST_true(EC_POINT_set_affine_coordinates(NISTP, Q_CHECK, x, y,
ctx))
|| !TEST_true(BN_hex2bn(&x, test->Gx))
|| !TEST_true(BN_hex2bn(&y, test->Gy))
|| !TEST_true(EC_POINT_set_affine_coordinates(NISTP, G, x, y, ctx))
|| !TEST_true(BN_hex2bn(&order, test->order))
|| !TEST_true(EC_GROUP_set_generator(NISTP, G, order, BN_value_one()))
|| !TEST_int_eq(EC_GROUP_get_degree(NISTP), test->degree))
goto err;
TEST_note("NIST test vectors ... ");
if (!TEST_true(BN_hex2bn(&n, test->d)))
goto err;
/* fixed point multiplication */
EC_POINT_mul(NISTP, Q, n, NULL, NULL, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx)))
goto err;
/* random point multiplication */
EC_POINT_mul(NISTP, Q, NULL, G, n, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx))
/* set generator to P = 2*G, where G is the standard generator */
|| !TEST_true(EC_POINT_dbl(NISTP, P, G, ctx))
|| !TEST_true(EC_GROUP_set_generator(NISTP, P, order, BN_value_one()))
/* set the scalar to m=n/2, where n is the NIST test scalar */
|| !TEST_true(BN_rshift(m, n, 1)))
goto err;
/* test the non-standard generator */
/* fixed point multiplication */
EC_POINT_mul(NISTP, Q, m, NULL, NULL, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx)))
goto err;
/* random point multiplication */
EC_POINT_mul(NISTP, Q, NULL, P, m, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx))
/*
* We have not performed precomputation so have_precompute mult should be
* false
*/
|| !TEST_false(EC_GROUP_have_precompute_mult(NISTP))
/* now repeat all tests with precomputation */
|| !TEST_true(EC_GROUP_precompute_mult(NISTP, ctx))
|| !TEST_true(EC_GROUP_have_precompute_mult(NISTP)))
goto err;
/* fixed point multiplication */
EC_POINT_mul(NISTP, Q, m, NULL, NULL, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx)))
goto err;
/* random point multiplication */
EC_POINT_mul(NISTP, Q, NULL, P, m, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx))
/* reset generator */
|| !TEST_true(EC_GROUP_set_generator(NISTP, G, order, BN_value_one())))
goto err;
/* fixed point multiplication */
EC_POINT_mul(NISTP, Q, n, NULL, NULL, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx)))
goto err;
/* random point multiplication */
EC_POINT_mul(NISTP, Q, NULL, G, n, ctx);
if (!TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, Q_CHECK, ctx)))
goto err;
/* regression test for felem_neg bug */
if (!TEST_true(BN_set_word(m, 32))
|| !TEST_true(BN_set_word(n, 31))
|| !TEST_true(EC_POINT_copy(P, G))
|| !TEST_true(EC_POINT_invert(NISTP, P, ctx))
|| !TEST_true(EC_POINT_mul(NISTP, Q, m, P, n, ctx))
|| !TEST_int_eq(0, EC_POINT_cmp(NISTP, Q, G, ctx)))
goto err;
r = group_order_tests(NISTP);
err:
EC_GROUP_free(NISTP);
EC_POINT_free(G);
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(Q_CHECK);
BN_free(n);
BN_free(m);
BN_free(p);
BN_free(a);
BN_free(b);
BN_free(x);
BN_free(y);
BN_free(order);
BN_free(yplusone);
BN_CTX_free(ctx);
return r;
}
/*
* Tests a point known to cause an incorrect underflow in an old version of
* ecp_nist521.c
*/
static int underflow_test(void)
{
BN_CTX *ctx = NULL;
EC_GROUP *grp = NULL;
EC_POINT *P = NULL, *Q = NULL, *R = NULL;
BIGNUM *x1 = NULL, *y1 = NULL, *z1 = NULL, *x2 = NULL, *y2 = NULL;
BIGNUM *k = NULL;
int testresult = 0;
const char *x1str =
"1534f0077fffffe87e9adcfe000000000000000000003e05a21d2400002e031b1f4"
"b80000c6fafa4f3c1288798d624a247b5e2ffffffffffffffefe099241900004";
const char *p521m1 =
"1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe";
ctx = BN_CTX_new();
if (!TEST_ptr(ctx))
return 0;
BN_CTX_start(ctx);
x1 = BN_CTX_get(ctx);
y1 = BN_CTX_get(ctx);
z1 = BN_CTX_get(ctx);
x2 = BN_CTX_get(ctx);
y2 = BN_CTX_get(ctx);
k = BN_CTX_get(ctx);
if (!TEST_ptr(k))
goto err;
grp = EC_GROUP_new_by_curve_name(NID_secp521r1);
P = EC_POINT_new(grp);
Q = EC_POINT_new(grp);
R = EC_POINT_new(grp);
if (!TEST_ptr(grp) || !TEST_ptr(P) || !TEST_ptr(Q) || !TEST_ptr(R))
goto err;
if (!TEST_int_gt(BN_hex2bn(&x1, x1str), 0)
|| !TEST_int_gt(BN_hex2bn(&y1, p521m1), 0)
|| !TEST_int_gt(BN_hex2bn(&z1, p521m1), 0)
|| !TEST_int_gt(BN_hex2bn(&k, "02"), 0)
|| !TEST_true(EC_POINT_set_Jprojective_coordinates_GFp(grp, P, x1,
y1, z1, ctx))
|| !TEST_true(EC_POINT_mul(grp, Q, NULL, P, k, ctx))
|| !TEST_true(EC_POINT_get_affine_coordinates(grp, Q, x1, y1, ctx))
|| !TEST_true(EC_POINT_dbl(grp, R, P, ctx))
|| !TEST_true(EC_POINT_get_affine_coordinates(grp, R, x2, y2, ctx)))
goto err;
if (!TEST_int_eq(BN_cmp(x1, x2), 0)
|| !TEST_int_eq(BN_cmp(y1, y2), 0))
goto err;
testresult = 1;
err:
BN_CTX_end(ctx);
EC_POINT_free(P);
EC_POINT_free(Q);
EC_POINT_free(R);
EC_GROUP_free(grp);
BN_CTX_free(ctx);
return testresult;
}
# endif
static const unsigned char p521_named[] = {
0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x23,
};
static const unsigned char p521_explicit[] = {
0x30, 0x82, 0x01, 0xc3, 0x02, 0x01, 0x01, 0x30, 0x4d, 0x06, 0x07, 0x2a,
0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x42, 0x01, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x30, 0x81, 0x9f, 0x04, 0x42, 0x01, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xfc, 0x04, 0x42, 0x00, 0x51, 0x95, 0x3e, 0xb9, 0x61, 0x8e, 0x1c, 0x9a,
0x1f, 0x92, 0x9a, 0x21, 0xa0, 0xb6, 0x85, 0x40, 0xee, 0xa2, 0xda, 0x72,
0x5b, 0x99, 0xb3, 0x15, 0xf3, 0xb8, 0xb4, 0x89, 0x91, 0x8e, 0xf1, 0x09,
0xe1, 0x56, 0x19, 0x39, 0x51, 0xec, 0x7e, 0x93, 0x7b, 0x16, 0x52, 0xc0,
0xbd, 0x3b, 0xb1, 0xbf, 0x07, 0x35, 0x73, 0xdf, 0x88, 0x3d, 0x2c, 0x34,
0xf1, 0xef, 0x45, 0x1f, 0xd4, 0x6b, 0x50, 0x3f, 0x00, 0x03, 0x15, 0x00,
0xd0, 0x9e, 0x88, 0x00, 0x29, 0x1c, 0xb8, 0x53, 0x96, 0xcc, 0x67, 0x17,
0x39, 0x32, 0x84, 0xaa, 0xa0, 0xda, 0x64, 0xba, 0x04, 0x81, 0x85, 0x04,
0x00, 0xc6, 0x85, 0x8e, 0x06, 0xb7, 0x04, 0x04, 0xe9, 0xcd, 0x9e, 0x3e,
0xcb, 0x66, 0x23, 0x95, 0xb4, 0x42, 0x9c, 0x64, 0x81, 0x39, 0x05, 0x3f,
0xb5, 0x21, 0xf8, 0x28, 0xaf, 0x60, 0x6b, 0x4d, 0x3d, 0xba, 0xa1, 0x4b,
0x5e, 0x77, 0xef, 0xe7, 0x59, 0x28, 0xfe, 0x1d, 0xc1, 0x27, 0xa2, 0xff,
0xa8, 0xde, 0x33, 0x48, 0xb3, 0xc1, 0x85, 0x6a, 0x42, 0x9b, 0xf9, 0x7e,
0x7e, 0x31, 0xc2, 0xe5, 0xbd, 0x66, 0x01, 0x18, 0x39, 0x29, 0x6a, 0x78,
0x9a, 0x3b, 0xc0, 0x04, 0x5c, 0x8a, 0x5f, 0xb4, 0x2c, 0x7d, 0x1b, 0xd9,
0x98, 0xf5, 0x44, 0x49, 0x57, 0x9b, 0x44, 0x68, 0x17, 0xaf, 0xbd, 0x17,
0x27, 0x3e, 0x66, 0x2c, 0x97, 0xee, 0x72, 0x99, 0x5e, 0xf4, 0x26, 0x40,
0xc5, 0x50, 0xb9, 0x01, 0x3f, 0xad, 0x07, 0x61, 0x35, 0x3c, 0x70, 0x86,
0xa2, 0x72, 0xc2, 0x40, 0x88, 0xbe, 0x94, 0x76, 0x9f, 0xd1, 0x66, 0x50,
0x02, 0x42, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa,
0x51, 0x86, 0x87, 0x83, 0xbf, 0x2f, 0x96, 0x6b, 0x7f, 0xcc, 0x01, 0x48,
0xf7, 0x09, 0xa5, 0xd0, 0x3b, 0xb5, 0xc9, 0xb8, 0x89, 0x9c, 0x47, 0xae,
0xbb, 0x6f, 0xb7, 0x1e, 0x91, 0x38, 0x64, 0x09, 0x02, 0x01, 0x01,
};
/*
* Sometime we cannot compare nids for equality, as the built-in curve table
* includes aliases with different names for the same curve.
*
* This function returns TRUE (1) if the checked nids are identical, or if they
* alias to the same curve. FALSE (0) otherwise.
*/
static ossl_inline
int are_ec_nids_compatible(int n1d, int n2d)
{
int ret = 0;
switch (n1d) {
# ifndef OPENSSL_NO_EC2M
case NID_sect113r1:
case NID_wap_wsg_idm_ecid_wtls4:
ret = (n2d == NID_sect113r1 || n2d == NID_wap_wsg_idm_ecid_wtls4);
break;
case NID_sect163k1:
case NID_wap_wsg_idm_ecid_wtls3:
ret = (n2d == NID_sect163k1 || n2d == NID_wap_wsg_idm_ecid_wtls3);
break;
case NID_sect233k1:
case NID_wap_wsg_idm_ecid_wtls10:
ret = (n2d == NID_sect233k1 || n2d == NID_wap_wsg_idm_ecid_wtls10);
break;
case NID_sect233r1:
case NID_wap_wsg_idm_ecid_wtls11:
ret = (n2d == NID_sect233r1 || n2d == NID_wap_wsg_idm_ecid_wtls11);
break;
case NID_X9_62_c2pnb163v1:
case NID_wap_wsg_idm_ecid_wtls5:
ret = (n2d == NID_X9_62_c2pnb163v1
|| n2d == NID_wap_wsg_idm_ecid_wtls5);
break;
# endif /* OPENSSL_NO_EC2M */
case NID_secp112r1:
case NID_wap_wsg_idm_ecid_wtls6:
ret = (n2d == NID_secp112r1 || n2d == NID_wap_wsg_idm_ecid_wtls6);
break;
case NID_secp160r2:
case NID_wap_wsg_idm_ecid_wtls7:
ret = (n2d == NID_secp160r2 || n2d == NID_wap_wsg_idm_ecid_wtls7);
break;
# ifdef OPENSSL_NO_EC_NISTP_64_GCC_128
case NID_secp224r1:
case NID_wap_wsg_idm_ecid_wtls12:
ret = (n2d == NID_secp224r1 || n2d == NID_wap_wsg_idm_ecid_wtls12);
break;
# else
/*
* For SEC P-224 we want to ensure that the SECP nid is returned, as
* that is associated with a specialized method.
*/
case NID_wap_wsg_idm_ecid_wtls12:
ret = (n2d == NID_secp224r1);
break;
# endif /* def(OPENSSL_NO_EC_NISTP_64_GCC_128) */
default:
ret = (n1d == n2d);
}
return ret;
}
/*
* This checks that EC_GROUP_bew_from_ecparameters() returns a "named"
* EC_GROUP for built-in curves.
*
* Note that it is possible to retrieve an alternative alias that does not match
* the original nid.
*
* Ensure that the OPENSSL_EC_EXPLICIT_CURVE ASN1 flag is set.
*/
static int check_named_curve_from_ecparameters(int id)
{
int ret = 0, nid, tnid;
EC_GROUP *group = NULL, *tgroup = NULL, *tmpg = NULL;
const EC_POINT *group_gen = NULL;
EC_POINT *other_gen = NULL;
BIGNUM *group_cofactor = NULL, *other_cofactor = NULL;
BIGNUM *other_gen_x = NULL, *other_gen_y = NULL;
const BIGNUM *group_order = NULL;
BIGNUM *other_order = NULL;
BN_CTX *bn_ctx = NULL;
static const unsigned char invalid_seed[] = "THIS IS NOT A VALID SEED";
static size_t invalid_seed_len = sizeof(invalid_seed);
ECPARAMETERS *params = NULL, *other_params = NULL;
EC_GROUP *g_ary[8] = {NULL};
EC_GROUP **g_next = &g_ary[0];
ECPARAMETERS *p_ary[8] = {NULL};
ECPARAMETERS **p_next = &p_ary[0];
/* Do some setup */
nid = curves[id].nid;
TEST_note("Curve %s", OBJ_nid2sn(nid));
if (!TEST_ptr(bn_ctx = BN_CTX_new()))
return ret;
BN_CTX_start(bn_ctx);
if (/* Allocations */
!TEST_ptr(group_cofactor = BN_CTX_get(bn_ctx))
|| !TEST_ptr(other_gen_x = BN_CTX_get(bn_ctx))
|| !TEST_ptr(other_gen_y = BN_CTX_get(bn_ctx))
|| !TEST_ptr(other_order = BN_CTX_get(bn_ctx))
|| !TEST_ptr(other_cofactor = BN_CTX_get(bn_ctx))
/* Generate reference group and params */
|| !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
|| !TEST_ptr(params = EC_GROUP_get_ecparameters(group, NULL))
|| !TEST_ptr(group_gen = EC_GROUP_get0_generator(group))
|| !TEST_ptr(group_order = EC_GROUP_get0_order(group))
|| !TEST_true(EC_GROUP_get_cofactor(group, group_cofactor, NULL))
/* compute `other_*` values */
|| !TEST_ptr(tmpg = EC_GROUP_dup(group))
|| !TEST_ptr(other_gen = EC_POINT_dup(group_gen, group))
|| !TEST_true(EC_POINT_add(group, other_gen, group_gen, group_gen, NULL))
|| !TEST_true(EC_POINT_get_affine_coordinates(group, other_gen,
other_gen_x, other_gen_y, bn_ctx))
|| !TEST_true(BN_copy(other_order, group_order))
|| !TEST_true(BN_add_word(other_order, 1))
|| !TEST_true(BN_copy(other_cofactor, group_cofactor))
|| !TEST_true(BN_add_word(other_cofactor, 1)))
goto err;
EC_POINT_free(other_gen);
other_gen = NULL;
if (!TEST_ptr(other_gen = EC_POINT_new(tmpg))
|| !TEST_true(EC_POINT_set_affine_coordinates(tmpg, other_gen,
other_gen_x, other_gen_y,
bn_ctx)))
goto err;
/*
* ###########################
* # Actual tests start here #
* ###########################
*/
/*
* Creating a group from built-in explicit parameters returns a
* "named" EC_GROUP
*/
if (!TEST_ptr(tgroup = *g_next++ = EC_GROUP_new_from_ecparameters(params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef))
goto err;
/*
* We cannot always guarantee the names match, as the built-in table
* contains aliases for the same curve with different names.
*/
if (!TEST_true(are_ec_nids_compatible(nid, tnid))) {
TEST_info("nid = %s, tnid = %s", OBJ_nid2sn(nid), OBJ_nid2sn(tnid));
goto err;
}
/* Ensure that the OPENSSL_EC_EXPLICIT_CURVE ASN1 flag is set. */
if (!TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup), OPENSSL_EC_EXPLICIT_CURVE))
goto err;
/*
* An invalid seed in the parameters should be ignored: expect a "named"
* group.
*/
if (!TEST_int_eq(EC_GROUP_set_seed(tmpg, invalid_seed, invalid_seed_len),
invalid_seed_len)
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
|| !TEST_true(are_ec_nids_compatible(nid, tnid))
|| !TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup),
OPENSSL_EC_EXPLICIT_CURVE)) {
TEST_info("nid = %s, tnid = %s", OBJ_nid2sn(nid), OBJ_nid2sn(tnid));
goto err;
}
/*
* A null seed in the parameters should be ignored, as it is optional:
* expect a "named" group.
*/
if (!TEST_int_eq(EC_GROUP_set_seed(tmpg, NULL, 0), 1)
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
|| !TEST_true(are_ec_nids_compatible(nid, tnid))
|| !TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup),
OPENSSL_EC_EXPLICIT_CURVE)) {
TEST_info("nid = %s, tnid = %s", OBJ_nid2sn(nid), OBJ_nid2sn(tnid));
goto err;
}
/*
* Check that changing any of the generator parameters does not yield a
* match with the built-in curves
*/
if (/* Other gen, same group order & cofactor */
!TEST_true(EC_GROUP_set_generator(tmpg, other_gen, group_order,
group_cofactor))
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_eq((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
/* Same gen & cofactor, different order */
|| !TEST_true(EC_GROUP_set_generator(tmpg, group_gen, other_order,
group_cofactor))
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_eq((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
/* The order is not an optional field, so this should fail */
|| !TEST_false(EC_GROUP_set_generator(tmpg, group_gen, NULL,
group_cofactor))
/* Check that a wrong cofactor is ignored, and we still match */
|| !TEST_true(EC_GROUP_set_generator(tmpg, group_gen, group_order,
other_cofactor))
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
|| !TEST_true(are_ec_nids_compatible(nid, tnid))
|| !TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup),
OPENSSL_EC_EXPLICIT_CURVE)
/* Check that if the cofactor is not set then it still matches */
|| !TEST_true(EC_GROUP_set_generator(tmpg, group_gen, group_order,
NULL))
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
|| !TEST_true(are_ec_nids_compatible(nid, tnid))
|| !TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup),
OPENSSL_EC_EXPLICIT_CURVE)
/* check that restoring the generator passes */
|| !TEST_true(EC_GROUP_set_generator(tmpg, group_gen, group_order,
group_cofactor))
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
EC_GROUP_new_from_ecparameters(other_params))
|| !TEST_int_ne((tnid = EC_GROUP_get_curve_name(tgroup)), NID_undef)
|| !TEST_true(are_ec_nids_compatible(nid, tnid))
|| !TEST_int_eq(EC_GROUP_get_asn1_flag(tgroup),
OPENSSL_EC_EXPLICIT_CURVE))
goto err;
ret = 1;
err:
for (g_next = &g_ary[0]; g_next < g_ary + OSSL_NELEM(g_ary); g_next++)
EC_GROUP_free(*g_next);
for (p_next = &p_ary[0]; p_next < p_ary + OSSL_NELEM(g_ary); p_next++)
ECPARAMETERS_free(*p_next);
ECPARAMETERS_free(params);
EC_POINT_free(other_gen);
EC_GROUP_free(tmpg);
EC_GROUP_free(group);
BN_CTX_end(bn_ctx);
BN_CTX_free(bn_ctx);
return ret;
}
static int parameter_test(void)
{
EC_GROUP *group = NULL, *group2 = NULL;
ECPARAMETERS *ecparameters = NULL;
unsigned char *buf = NULL;
int r = 0, len;
if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(NID_secp112r1))
|| !TEST_ptr(ecparameters = EC_GROUP_get_ecparameters(group, NULL))
|| !TEST_ptr(group2 = EC_GROUP_new_from_ecparameters(ecparameters))
|| !TEST_int_eq(EC_GROUP_cmp(group, group2, NULL), 0))
goto err;
EC_GROUP_free(group);
group = NULL;
/* Test the named curve encoding, which should be default. */
if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(NID_secp521r1))
|| !TEST_true((len = i2d_ECPKParameters(group, &buf)) >= 0)
|| !TEST_mem_eq(buf, len, p521_named, sizeof(p521_named)))
goto err;
OPENSSL_free(buf);
buf = NULL;
/*
* Test the explicit encoding. P-521 requires correctly zero-padding the
* curve coefficients.
*/
EC_GROUP_set_asn1_flag(group, OPENSSL_EC_EXPLICIT_CURVE);
if (!TEST_true((len = i2d_ECPKParameters(group, &buf)) >= 0)
|| !TEST_mem_eq(buf, len, p521_explicit, sizeof(p521_explicit)))
goto err;
r = 1;
err:
EC_GROUP_free(group);
EC_GROUP_free(group2);
ECPARAMETERS_free(ecparameters);
OPENSSL_free(buf);
return r;
}
/*-
* random 256-bit explicit parameters curve, cofactor absent
* order: 0x0c38d96a9f892b88772ec2e39614a82f4f (132 bit)
* cofactor: 0x12bc94785251297abfafddf1565100da (125 bit)
*/
static const unsigned char params_cf_pass[] = {
0x30, 0x81, 0xcd, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86,
0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xe5, 0x00, 0x1f, 0xc5,
0xca, 0x71, 0x9d, 0x8e, 0xf7, 0x07, 0x4b, 0x48, 0x37, 0xf9, 0x33, 0x2d,
0x71, 0xbf, 0x79, 0xe7, 0xdc, 0x91, 0xc2, 0xff, 0xb6, 0x7b, 0xc3, 0x93,
0x44, 0x88, 0xe6, 0x91, 0x30, 0x44, 0x04, 0x20, 0xe5, 0x00, 0x1f, 0xc5,
0xca, 0x71, 0x9d, 0x8e, 0xf7, 0x07, 0x4b, 0x48, 0x37, 0xf9, 0x33, 0x2d,
0x71, 0xbf, 0x79, 0xe7, 0xdc, 0x91, 0xc2, 0xff, 0xb6, 0x7b, 0xc3, 0x93,
0x44, 0x88, 0xe6, 0x8e, 0x04, 0x20, 0x18, 0x8c, 0x59, 0x57, 0xc4, 0xbc,
0x85, 0x57, 0xc3, 0x66, 0x9f, 0x89, 0xd5, 0x92, 0x0d, 0x7e, 0x42, 0x27,
0x07, 0x64, 0xaa, 0x26, 0xed, 0x89, 0xc4, 0x09, 0x05, 0x4d, 0xc7, 0x23,
0x47, 0xda, 0x04, 0x41, 0x04, 0x1b, 0x6b, 0x41, 0x0b, 0xf9, 0xfb, 0x77,
0xfd, 0x50, 0xb7, 0x3e, 0x23, 0xa3, 0xec, 0x9a, 0x3b, 0x09, 0x31, 0x6b,
0xfa, 0xf6, 0xce, 0x1f, 0xff, 0xeb, 0x57, 0x93, 0x24, 0x70, 0xf3, 0xf4,
0xba, 0x7e, 0xfa, 0x86, 0x6e, 0x19, 0x89, 0xe3, 0x55, 0x6d, 0x5a, 0xe9,
0xc0, 0x3d, 0xbc, 0xfb, 0xaf, 0xad, 0xd4, 0x7e, 0xa6, 0xe5, 0xfa, 0x1a,
0x58, 0x07, 0x9e, 0x8f, 0x0d, 0x3b, 0xf7, 0x38, 0xca, 0x02, 0x11, 0x0c,
0x38, 0xd9, 0x6a, 0x9f, 0x89, 0x2b, 0x88, 0x77, 0x2e, 0xc2, 0xe3, 0x96,
0x14, 0xa8, 0x2f, 0x4f
};
/*-
* random 256-bit explicit parameters curve, cofactor absent
* order: 0x045a75c0c17228ebd9b169a10e34a22101 (131 bit)
* cofactor: 0x2e134b4ede82649f67a2e559d361e5fe (126 bit)
*/
static const unsigned char params_cf_fail[] = {
0x30, 0x81, 0xcd, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86,
0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xc8, 0x95, 0x27, 0x37,
0xe8, 0xe1, 0xfd, 0xcc, 0xf9, 0x6e, 0x0c, 0xa6, 0x21, 0xc1, 0x7d, 0x6b,
0x9d, 0x44, 0x42, 0xea, 0x73, 0x4e, 0x04, 0xb6, 0xac, 0x62, 0x50, 0xd0,
0x33, 0xc2, 0xea, 0x13, 0x30, 0x44, 0x04, 0x20, 0xc8, 0x95, 0x27, 0x37,
0xe8, 0xe1, 0xfd, 0xcc, 0xf9, 0x6e, 0x0c, 0xa6, 0x21, 0xc1, 0x7d, 0x6b,
0x9d, 0x44, 0x42, 0xea, 0x73, 0x4e, 0x04, 0xb6, 0xac, 0x62, 0x50, 0xd0,
0x33, 0xc2, 0xea, 0x10, 0x04, 0x20, 0xbf, 0xa6, 0xa8, 0x05, 0x1d, 0x09,
0xac, 0x70, 0x39, 0xbb, 0x4d, 0xb2, 0x90, 0x8a, 0x15, 0x41, 0x14, 0x1d,
0x11, 0x86, 0x9f, 0x13, 0xa2, 0x63, 0x1a, 0xda, 0x95, 0x22, 0x4d, 0x02,
0x15, 0x0a, 0x04, 0x41, 0x04, 0xaf, 0x16, 0x71, 0xf9, 0xc4, 0xc8, 0x59,
0x1d, 0xa3, 0x6f, 0xe7, 0xc3, 0x57, 0xa1, 0xfa, 0x9f, 0x49, 0x7c, 0x11,
0x27, 0x05, 0xa0, 0x7f, 0xff, 0xf9, 0xe0, 0xe7, 0x92, 0xdd, 0x9c, 0x24,
0x8e, 0xc7, 0xb9, 0x52, 0x71, 0x3f, 0xbc, 0x7f, 0x6a, 0x9f, 0x35, 0x70,
0xe1, 0x27, 0xd5, 0x35, 0x8a, 0x13, 0xfa, 0xa8, 0x33, 0x3e, 0xd4, 0x73,
0x1c, 0x14, 0x58, 0x9e, 0xc7, 0x0a, 0x87, 0x65, 0x8d, 0x02, 0x11, 0x04,
0x5a, 0x75, 0xc0, 0xc1, 0x72, 0x28, 0xeb, 0xd9, 0xb1, 0x69, 0xa1, 0x0e,
0x34, 0xa2, 0x21, 0x01
};
/*-
* Test two random 256-bit explicit parameters curves with absent cofactor.
* The two curves are chosen to roughly straddle the bounds at which the lib
* can compute the cofactor automatically, roughly 4*sqrt(p). So test that:
*
* - params_cf_pass: order is sufficiently close to p to compute cofactor
* - params_cf_fail: order is too far away from p to compute cofactor
*
* For standards-compliant curves, cofactor is chosen as small as possible.
* So you can see neither of these curves are fit for cryptographic use.
*
* Some standards even mandate an upper bound on the cofactor, e.g. SECG1 v2:
* h <= 2**(t/8) where t is the security level of the curve, for which the lib
* will always succeed in computing the cofactor. Neither of these curves
* conform to that -- this is just robustness testing.
*/
static int cofactor_range_test(void)
{
EC_GROUP *group = NULL;
BIGNUM *cf = NULL;
int ret = 0;
const unsigned char *b1 = (const unsigned char *)params_cf_fail;
const unsigned char *b2 = (const unsigned char *)params_cf_pass;
if (!TEST_ptr(group = d2i_ECPKParameters(NULL, &b1, sizeof(params_cf_fail)))
|| !TEST_BN_eq_zero(EC_GROUP_get0_cofactor(group))
|| !TEST_ptr(group = d2i_ECPKParameters(&group, &b2,
sizeof(params_cf_pass)))
|| !TEST_int_gt(BN_hex2bn(&cf, "12bc94785251297abfafddf1565100da"), 0)
|| !TEST_BN_eq(cf, EC_GROUP_get0_cofactor(group)))
goto err;
ret = 1;
err:
BN_free(cf);
EC_GROUP_free(group);
return ret;
}
/*-
* For named curves, test that:
* - the lib correctly computes the cofactor if passed a NULL or zero cofactor
* - a nonsensical cofactor throws an error (negative test)
* - nonsensical orders throw errors (negative tests)
*/
static int cardinality_test(int n)
{
int ret = 0;
int nid = curves[n].nid;
BN_CTX *ctx = NULL;
EC_GROUP *g1 = NULL, *g2 = NULL;
EC_POINT *g2_gen = NULL;
BIGNUM *g1_p = NULL, *g1_a = NULL, *g1_b = NULL, *g1_x = NULL, *g1_y = NULL,
*g1_order = NULL, *g1_cf = NULL, *g2_cf = NULL;
TEST_info("Curve %s cardinality test", OBJ_nid2sn(nid));
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(g1 = EC_GROUP_new_by_curve_name(nid))
|| !TEST_ptr(g2 = EC_GROUP_new(EC_GROUP_method_of(g1)))) {
EC_GROUP_free(g1);
EC_GROUP_free(g2);
BN_CTX_free(ctx);
return 0;
}
BN_CTX_start(ctx);
g1_p = BN_CTX_get(ctx);
g1_a = BN_CTX_get(ctx);
g1_b = BN_CTX_get(ctx);
g1_x = BN_CTX_get(ctx);
g1_y = BN_CTX_get(ctx);
g1_order = BN_CTX_get(ctx);
g1_cf = BN_CTX_get(ctx);
if (!TEST_ptr(g2_cf = BN_CTX_get(ctx))
/* pull out the explicit curve parameters */
|| !TEST_true(EC_GROUP_get_curve(g1, g1_p, g1_a, g1_b, ctx))
|| !TEST_true(EC_POINT_get_affine_coordinates(g1,
EC_GROUP_get0_generator(g1), g1_x, g1_y, ctx))
|| !TEST_true(BN_copy(g1_order, EC_GROUP_get0_order(g1)))
|| !TEST_true(EC_GROUP_get_cofactor(g1, g1_cf, ctx))
/* construct g2 manually with g1 parameters */
|| !TEST_true(EC_GROUP_set_curve(g2, g1_p, g1_a, g1_b, ctx))
|| !TEST_ptr(g2_gen = EC_POINT_new(g2))
|| !TEST_true(EC_POINT_set_affine_coordinates(g2, g2_gen, g1_x, g1_y, ctx))
/* pass NULL cofactor: lib should compute it */
|| !TEST_true(EC_GROUP_set_generator(g2, g2_gen, g1_order, NULL))
|| !TEST_true(EC_GROUP_get_cofactor(g2, g2_cf, ctx))
|| !TEST_BN_eq(g1_cf, g2_cf)
/* pass zero cofactor: lib should compute it */
|| !TEST_true(BN_set_word(g2_cf, 0))
|| !TEST_true(EC_GROUP_set_generator(g2, g2_gen, g1_order, g2_cf))
|| !TEST_true(EC_GROUP_get_cofactor(g2, g2_cf, ctx))
|| !TEST_BN_eq(g1_cf, g2_cf)
/* negative test for invalid cofactor */
|| !TEST_true(BN_set_word(g2_cf, 0))
|| !TEST_true(BN_sub(g2_cf, g2_cf, BN_value_one()))
|| !TEST_false(EC_GROUP_set_generator(g2, g2_gen, g1_order, g2_cf))
/* negative test for NULL order */
|| !TEST_false(EC_GROUP_set_generator(g2, g2_gen, NULL, NULL))
/* negative test for zero order */
|| !TEST_true(BN_set_word(g1_order, 0))
|| !TEST_false(EC_GROUP_set_generator(g2, g2_gen, g1_order, NULL))
/* negative test for negative order */
|| !TEST_true(BN_set_word(g2_cf, 0))
|| !TEST_true(BN_sub(g2_cf, g2_cf, BN_value_one()))
|| !TEST_false(EC_GROUP_set_generator(g2, g2_gen, g1_order, NULL))
/* negative test for too large order */
|| !TEST_true(BN_lshift(g1_order, g1_p, 2))
|| !TEST_false(EC_GROUP_set_generator(g2, g2_gen, g1_order, NULL)))
goto err;
ret = 1;
err:
EC_POINT_free(g2_gen);
EC_GROUP_free(g1);
EC_GROUP_free(g2);
BN_CTX_end(ctx);
BN_CTX_free(ctx);
return ret;
}
/*
* Helper for ec_point_hex2point_test
*
* Self-tests EC_POINT_point2hex() against EC_POINT_hex2point() for the given
* (group,P) pair.
*
* If P is NULL use point at infinity.
*/
static ossl_inline
int ec_point_hex2point_test_helper(const EC_GROUP *group, const EC_POINT *P,
point_conversion_form_t form,
BN_CTX *bnctx)
{
int ret = 0;
EC_POINT *Q = NULL, *Pinf = NULL;
char *hex = NULL;
if (P == NULL) {
/* If P is NULL use point at infinity. */
if (!TEST_ptr(Pinf = EC_POINT_new(group))
|| !TEST_true(EC_POINT_set_to_infinity(group, Pinf)))
goto err;
P = Pinf;
}
if (!TEST_ptr(hex = EC_POINT_point2hex(group, P, form, bnctx))
|| !TEST_ptr(Q = EC_POINT_hex2point(group, hex, NULL, bnctx))
|| !TEST_int_eq(0, EC_POINT_cmp(group, Q, P, bnctx)))
goto err;
/*
* The next check is most likely superfluous, as EC_POINT_cmp should already
* cover this.
* Nonetheless it increases the test coverage for EC_POINT_is_at_infinity,
* so we include it anyway!
*/
if (Pinf != NULL
&& !TEST_true(EC_POINT_is_at_infinity(group, Q)))
goto err;
ret = 1;
err:
EC_POINT_free(Pinf);
OPENSSL_free(hex);
EC_POINT_free(Q);
return ret;
}
/*
* This test self-validates EC_POINT_hex2point() and EC_POINT_point2hex()
*/
static int ec_point_hex2point_test(int id)
{
int ret = 0, nid;
EC_GROUP *group = NULL;
const EC_POINT *G = NULL;
EC_POINT *P = NULL;
BN_CTX * bnctx = NULL;
/* Do some setup */
nid = curves[id].nid;
if (!TEST_ptr(bnctx = BN_CTX_new())
|| !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
|| !TEST_ptr(G = EC_GROUP_get0_generator(group))
|| !TEST_ptr(P = EC_POINT_dup(G, group)))
goto err;
if (!TEST_true(ec_point_hex2point_test_helper(group, P,
POINT_CONVERSION_COMPRESSED,
bnctx))
|| !TEST_true(ec_point_hex2point_test_helper(group, NULL,
POINT_CONVERSION_COMPRESSED,
bnctx))
|| !TEST_true(ec_point_hex2point_test_helper(group, P,
POINT_CONVERSION_UNCOMPRESSED,
bnctx))
|| !TEST_true(ec_point_hex2point_test_helper(group, NULL,
POINT_CONVERSION_UNCOMPRESSED,
bnctx))
|| !TEST_true(ec_point_hex2point_test_helper(group, P,
POINT_CONVERSION_HYBRID,
bnctx))
|| !TEST_true(ec_point_hex2point_test_helper(group, NULL,
POINT_CONVERSION_HYBRID,
bnctx)))
goto err;
ret = 1;
err:
EC_POINT_free(P);
EC_GROUP_free(group);
BN_CTX_free(bnctx);
return ret;
}
/*
* check the EC_METHOD respects the supplied EC_GROUP_set_generator G
*/
static int custom_generator_test(int id)
{
int ret = 0, nid, bsize;
EC_GROUP *group = NULL;
EC_POINT *G2 = NULL, *Q1 = NULL, *Q2 = NULL;
BN_CTX *ctx = NULL;
BIGNUM *k = NULL;
unsigned char *b1 = NULL, *b2 = NULL;
/* Do some setup */
nid = curves[id].nid;
TEST_note("Curve %s", OBJ_nid2sn(nid));
if (!TEST_ptr(ctx = BN_CTX_new()))
return 0;
BN_CTX_start(ctx);
if (!TEST_ptr(group = EC_GROUP_new_by_curve_name(nid)))
goto err;
/* expected byte length of encoded points */
bsize = (EC_GROUP_get_degree(group) + 7) / 8;
bsize = 2 * bsize + 1;
if (!TEST_ptr(k = BN_CTX_get(ctx))
/* fetch a testing scalar k != 0,1 */
|| !TEST_true(BN_rand(k, EC_GROUP_order_bits(group) - 1,
BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY))
/* make k even */
|| !TEST_true(BN_clear_bit(k, 0))
|| !TEST_ptr(G2 = EC_POINT_new(group))
|| !TEST_ptr(Q1 = EC_POINT_new(group))
/* Q1 := kG */
|| !TEST_true(EC_POINT_mul(group, Q1, k, NULL, NULL, ctx))
/* pull out the bytes of that */
|| !TEST_int_eq(EC_POINT_point2oct(group, Q1,
POINT_CONVERSION_UNCOMPRESSED, NULL,
0, ctx), bsize)
|| !TEST_ptr(b1 = OPENSSL_malloc(bsize))
|| !TEST_int_eq(EC_POINT_point2oct(group, Q1,
POINT_CONVERSION_UNCOMPRESSED, b1,
bsize, ctx), bsize)
/* new generator is G2 := 2G */
|| !TEST_true(EC_POINT_dbl(group, G2, EC_GROUP_get0_generator(group),
ctx))
|| !TEST_true(EC_GROUP_set_generator(group, G2,
EC_GROUP_get0_order(group),
EC_GROUP_get0_cofactor(group)))
|| !TEST_ptr(Q2 = EC_POINT_new(group))
|| !TEST_true(BN_rshift1(k, k))
/* Q2 := k/2 G2 */
|| !TEST_true(EC_POINT_mul(group, Q2, k, NULL, NULL, ctx))
|| !TEST_int_eq(EC_POINT_point2oct(group, Q2,
POINT_CONVERSION_UNCOMPRESSED, NULL,
0, ctx), bsize)
|| !TEST_ptr(b2 = OPENSSL_malloc(bsize))
|| !TEST_int_eq(EC_POINT_point2oct(group, Q2,
POINT_CONVERSION_UNCOMPRESSED, b2,
bsize, ctx), bsize)
/* Q1 = kG = k/2 G2 = Q2 should hold */
|| !TEST_int_eq(CRYPTO_memcmp(b1, b2, bsize), 0))
goto err;
ret = 1;
err:
BN_CTX_end(ctx);
EC_POINT_free(Q1);
EC_POINT_free(Q2);
EC_POINT_free(G2);
EC_GROUP_free(group);
BN_CTX_free(ctx);
OPENSSL_free(b1);
OPENSSL_free(b2);
return ret;
}
#endif /* OPENSSL_NO_EC */
int setup_tests(void)
{
#ifndef OPENSSL_NO_EC
crv_len = EC_get_builtin_curves(NULL, 0);
if (!TEST_ptr(curves = OPENSSL_malloc(sizeof(*curves) * crv_len))
|| !TEST_true(EC_get_builtin_curves(curves, crv_len)))
return 0;
ADD_TEST(parameter_test);
ADD_TEST(cofactor_range_test);
ADD_ALL_TESTS(cardinality_test, crv_len);
ADD_TEST(prime_field_tests);
# ifndef OPENSSL_NO_EC2M
ADD_TEST(hybrid_point_encoding_test);
ADD_TEST(char2_field_tests);
ADD_ALL_TESTS(char2_curve_test, OSSL_NELEM(char2_curve_tests));
# endif
# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
ADD_ALL_TESTS(nistp_single_test, OSSL_NELEM(nistp_tests_params));
ADD_TEST(underflow_test);
# endif
ADD_ALL_TESTS(internal_curve_test, crv_len);
ADD_ALL_TESTS(internal_curve_test_method, crv_len);
ADD_ALL_TESTS(check_named_curve_from_ecparameters, crv_len);
ADD_ALL_TESTS(ec_point_hex2point_test, crv_len);
ADD_ALL_TESTS(custom_generator_test, crv_len);
#endif /* OPENSSL_NO_EC */
return 1;
}
void cleanup_tests(void)
{
#ifndef OPENSSL_NO_EC
OPENSSL_free(curves);
#endif
}
|
1004315.c | /* Public domain */
#include "agartest.h"
static AG_Font *myFont;
static void
SelectedFont(AG_Event *event)
{
/* AG_Window *win = AG_WINDOW_PTR(1); */
if (myFont) {
AG_SetDefaultFont(myFont);
AG_SetString(agConfig, "font.face", AGOBJECT(agDefaultFont)->name);
AG_SetInt(agConfig, "font.size", agDefaultFont->spec.size);
AG_SetUint(agConfig, "font.flags", agDefaultFont->flags);
if (AG_ConfigSave() == 0) {
AG_TextTmsg(AG_MSG_INFO, 1000, "Default font has changed.");
} else {
AG_TextMsgFromError();
}
}
}
static int
TestGUI(void *obj, AG_Window *win)
{
AG_FontSelector *fs;
AG_Box *box;
int i;
myFont = agDefaultFont;
TestMsg(obj,
"Al-arabiyyah: "
AGSI_UNI
"\xD9\x8F\xD8\xA9\xD9\x91\xD9\x8E"
"\xD9\x8A\xD9\x90\xD8\xA8\xD9\x8E"
"\xD8\xB1\xD9\x8E\xD8\xB9\xD9\x92"
"\xD9\x84\xD9\x8E\xD8\xA7"
AGSI_RST);
TestMsg(obj,
"Devanagari: "
AGSI_UNI
"\xE0\xA4\xA6 " /* U+0926 DA */
"\xE0\xA4\xB5 " /* U+0926 VA */
"\xE0\xA4\xA8 " /* U+0928 NA */
"\xE0\xA4\x97 " /* U+0917 GA */
"\xE0\xA4\xB0 " /* U+0917 RA */
AGSI_RST);
TestMsg(obj,
"Ellinik\xC3\xA1: "
AGSI_UNI
"\xCE\xB5"
"\xCE\xBB"
"\xCE\xBB"
"\xCE\xB7"
"\xCE\xBD"
"\xCE\xB9"
"\xCE\xBA"
"\xCE\xAC"
AGSI_RST);
TestMsg(obj,
"Gu\xC4\x81nhu\xC3\xA0: "
AGSI_CJK
"\xE5\xAE\x98" /* U+5b98 */
"\xE8\xAF\x9D" /* U+8bdd */
AGSI_RST);
TestMsg(obj,
"Hanguk-eo: "
AGSI_CJK
"\xED\x95\x9C"
"\xEA\xB5\xAD"
"\xEC\x96\xB4"
AGSI_RST);
TestMsg(obj,
"Ivrit: "
AGSI_UNI
"\xD7\xAA"
"\xD7\x99"
"\xD7\xA8"
"\xD7\x91"
"\xD7\xA2"
AGSI_RST);
TestMsg(obj,
"Inuktitut: "
AGSI_UNI
"\xE1\x90\x83"
"\xE1\x93\x84"
"\xE1\x92\x83"
"\xE1\x91\x8E"
"\xE1\x91\x90"
"\xE1\x91\xA6"
AGSI_RST);
TestMsg(obj,
"Kartuli: "
AGSI_UNI
"\xE1\x83\xA5"
"\xE1\x83\x90"
"\xE1\x83\xA0"
"\xE1\x83\x97"
"\xE1\x83\xA3"
"\xE1\x83\x9A"
"\xE1\x83\x98"
AGSI_RST);
TestMsg(obj,
"Nihongo: "
AGSI_CJK
"\xE6\x97\xA5"
"\xE6\x9C\xAC"
"\xE8\xAA\x9E"
AGSI_RST);
TestMsg(obj,
"Phasa Lao: "
AGSI_UNI
"\xE0\xBA\x9E"
"\xE0\xBA\xB2"
"\xE0\xBA\xAA"
"\xE0\xBA\xB2"
"\xE0\xBA\xA5"
"\xE0\xBA\xB2"
"\xE0\xBA\xA7"
AGSI_RST);
TestMsg(obj,
"Phasa Thai: "
AGSI_UNI
"\xE0\xB8\xA0"
"\xE0\xB8\xB2"
"\xE0\xB8\xA9"
"\xE0\xB8\xB2"
"\xE0\xB9\x84"
"\xE0\xB8\x97"
"\xE0\xB8\xA2"
AGSI_RST);
TestMsg(obj,
"Russkiy: "
AGSI_UNI
"\xD1\x80"
"\xD1\x83"
"\xD1\x81"
"\xD1\x81"
"\xD0\xBA"
"\xD0\xB8"
"\xD0\xB9"
AGSI_RST);
TestMsg(obj,
"Tibetan digits: "
AGSI_UNI
"\xE0\xBC\xA0 "
"\xE0\xBC\xA1 "
"\xE0\xBC\xA2 "
"\xE0\xBC\xA3 "
"\xE0\xBC\xA4 "
"\xE0\xBC\xA5 "
"\xE0\xBC\xA6 "
"\xE0\xBC\xA7 "
"\xE0\xBC\xA8 "
AGSI_RST);
TestMsg(obj, "");
for (i = 0; i <= 10; i++) {
TestMsg(obj,
"Core Font #%d (AGSI_FONT%d): \x1b[%dm%s\x1b[0m",
i+1, i+1, 10+i, agCoreFonts[i]);
}
fs = AG_FontSelectorNew(win, AG_FONTSELECTOR_EXPAND);
AG_BindPointer(fs, "font", (void *)&myFont);
box = AG_BoxNewHoriz(win, AG_BOX_HFILL | AG_BOX_HOMOGENOUS);
{
AG_ButtonNewFn(box, 0, _("Set as Default Font"), SelectedFont, "%p", win);
AG_ButtonNewFn(box, 0, _("Cancel"), AGWINCLOSE(win));
}
return (0);
}
#if 0
/*
* Unsafe microbenchmark (calls AG_TextRender() and AG_TextSize() outside
* of rendering context).
*/
static void
TextSize_UTF8(void *obj)
{
int w, h;
int i;
for (i = 0; i < 50; i++)
AG_TextSize("The Quick Brown Fox Jumps Over The Lazy Dog", &w, &h);
}
static void
TextSize_Nat(void *obj)
{
AG_Char text[] = { 'T','h','e',' ','Q','u','i','c','k',' ',
'B','r','o','w','n',' ','F','o','x',' ',
'J','u','m','p','s',' ','O','v','e','r',' ',
'T','h','e',' ','L','a','z','y',' ',
'D','o','g', '\0' };
int w, h;
int i;
for (i = 0; i < 50; i++)
AG_TextSizeInternal(text, &w, &h);
}
static void
TextRender_UTF8(void *obj)
{
AG_Surface *S;
S = AG_TextRender("The Quick Brown Fox Jumps Over The Lazy Dog");
AG_SurfaceFree(S);
}
static void
TextRender_Nat(void *obj)
{
AG_Char text[] = { 'T','h','e',' ','Q','u','i','c','k',' ',
'B','r','o','w','n',' ','F','o','x',' ',
'J','u','m','p','s',' ','O','v','e','r',' ',
'T','h','e',' ','L','a','z','y',' ','D','o','g',
'\0' };
const AG_TextState *ts = AG_TEXT_STATE_CUR();
AG_Surface *S;
S = AG_TextRenderInternal(text, ts->font, &ts->colorBG, &ts->color);
AG_SurfaceFree(S);
}
static void
TextRender_2L(void *obj)
{
AG_Surface *S;
S = AG_TextRender("The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n");
AG_SurfaceFree(S);
}
static void
TextRender_3L(void *obj)
{
AG_Surface *S;
S = AG_TextRender("The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n");
AG_SurfaceFree(S);
}
static void
TextRender_4L(void *obj)
{
AG_Surface *S;
S = AG_TextRender("The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n"
"The Quick Brown Fox Jumps Over The Lazy Dog\n");
AG_SurfaceFree(S);
}
static struct ag_benchmark_fn fontBenchFns[] = {
{ "TextSize_Nat", TextSize_Nat },
{ "TextSize_UTF8", TextSize_UTF8 },
{ "TextRender_Nat", TextRender_Nat },
{ "TextRender_UTF8", TextRender_UTF8 },
{ "TextRender_2L", TextRender_2L },
{ "TextRender_3L", TextRender_3L },
{ "TextRender_4L", TextRender_4L },
};
static struct ag_benchmark fontBench = {
"Fonts",
&fontBenchFns[0],
sizeof(fontBenchFns) / sizeof(fontBenchFns[0]),
10, 500, 2000000000
};
static int
Bench(void *obj)
{
AG_TestInstance *ti = obj;
TestMsgS(ti, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
TestMsgS(ti, "abcdefghijklmnopqrstuvwxyz");
TestMsgS(ti, "0123456789-=.,;`[]'~!@#$%^&*()_+\\/");
TestExecBenchmark(obj, &fontBench);
return (0);
}
#endif
const AG_TestCase fontsTest = {
"fonts",
N_("Test font engine and AG_FontSelector(3)"),
"1.6.0",
0,
sizeof(AG_TestInstance),
NULL, /* init */
NULL, /* destroy */
NULL, /* test */
TestGUI,
NULL, /* bench */
};
|
290129.c | /*
* Copyright (c) 2016 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <vnet/ip/ip.h>
#include <vnet/ip/ip_source_and_port_range_check.h>
#include <vnet/dpo/load_balance.h>
#include <vnet/fib/fib_table.h>
#include <vnet/fib/ip4_fib.h>
source_range_check_main_t source_range_check_main;
/**
* @file
* @brief IPv4 Source and Port Range Checking.
*
* This file contains the source code for IPv4 source and port range
* checking.
*/
/**
* @brief The pool of range chack DPOs
*/
static protocol_port_range_dpo_t *ppr_dpo_pool;
/**
* @brief Dynamically registered DPO type
*/
static dpo_type_t ppr_dpo_type;
vlib_node_registration_t ip4_source_port_and_range_check_rx;
vlib_node_registration_t ip4_source_port_and_range_check_tx;
#define foreach_ip4_source_and_port_range_check_error \
_(CHECK_FAIL, "ip4 source and port range check bad packets") \
_(CHECK_OK, "ip4 source and port range check good packets")
typedef enum
{
#define _(sym,str) IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_##sym,
foreach_ip4_source_and_port_range_check_error
#undef _
IP4_SOURCE_AND_PORT_RANGE_CHECK_N_ERROR,
} ip4_source_and_port_range_check_error_t;
static char *ip4_source_and_port_range_check_error_strings[] = {
#define _(sym,string) string,
foreach_ip4_source_and_port_range_check_error
#undef _
};
typedef struct
{
u32 pass;
u32 bypass;
u32 is_tcp;
ip4_address_t src_addr;
u16 port;
u32 fib_index;
} ip4_source_and_port_range_check_trace_t;
static u8 *
format_ip4_source_and_port_range_check_trace (u8 * s, va_list * va)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
ip4_source_and_port_range_check_trace_t *t =
va_arg (*va, ip4_source_and_port_range_check_trace_t *);
if (t->bypass)
s = format (s, "PASS (bypass case)");
else
s = format (s, "fib %d src ip %U %s dst port %d: %s",
t->fib_index, format_ip4_address, &t->src_addr,
t->is_tcp ? "TCP" : "UDP", (u32) t->port,
(t->pass == 1) ? "PASS" : "FAIL");
return s;
}
typedef enum
{
IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP,
IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
} ip4_source_and_port_range_check_next_t;
static inline u32
check_adj_port_range_x1 (const protocol_port_range_dpo_t * ppr_dpo,
u16 dst_port, u32 next)
{
u16x8vec_t key;
u16x8vec_t diff1;
u16x8vec_t diff2;
u16x8vec_t sum, sum_equal_diff2;
u16 sum_nonzero, sum_equal, winner_mask;
int i;
if (NULL == ppr_dpo || dst_port == 0)
return IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP;
/* Make the obvious screw-case work. A variant also works w/ no MMX */
if (PREDICT_FALSE (dst_port == 65535))
{
int j;
for (i = 0;
i < VLIB_BUFFER_PRE_DATA_SIZE / sizeof (protocol_port_range_t);
i++)
{
for (j = 0; j < 8; j++)
if (ppr_dpo->blocks[i].low.as_u16[j] == 65535)
return next;
}
return IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP;
}
key.as_u16x8 = u16x8_splat (dst_port);
for (i = 0; i < ppr_dpo->n_used_blocks; i++)
{
diff1.as_u16x8 =
u16x8_sub_saturate (ppr_dpo->blocks[i].low.as_u16x8, key.as_u16x8);
diff2.as_u16x8 =
u16x8_sub_saturate (ppr_dpo->blocks[i].hi.as_u16x8, key.as_u16x8);
sum.as_u16x8 = diff1.as_u16x8 + diff2.as_u16x8;
sum_equal_diff2.as_u16x8 = (sum.as_u16x8 == diff2.as_u16x8);
sum_nonzero = ~u16x8_zero_byte_mask (sum.as_u16x8);
sum_equal = ~u16x8_zero_byte_mask (sum_equal_diff2.as_u16x8);
winner_mask = sum_nonzero & sum_equal;
if (winner_mask)
return next;
}
return IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP;
}
always_inline protocol_port_range_dpo_t *
protocol_port_range_dpo_get (index_t index)
{
return (pool_elt_at_index (ppr_dpo_pool, index));
}
always_inline uword
ip4_source_and_port_range_check_inline (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame, int is_tx)
{
ip4_main_t *im = &ip4_main;
u32 n_left_from, *from, *to_next;
u32 next_index;
vlib_node_runtime_t *error_node = node;
u32 good_packets = 0;
int i;
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
next_index = node->cached_next_index;
while (n_left_from > 0)
{
u32 n_left_to_next;
vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
/* while (n_left_from >= 4 && n_left_to_next >= 2) */
/* { */
/* vlib_buffer_t *b0, *b1; */
/* ip4_header_t *ip0, *ip1; */
/* ip4_fib_mtrie_t *mtrie0, *mtrie1; */
/* ip4_fib_mtrie_leaf_t leaf0, leaf1; */
/* ip_source_and_port_range_check_config_t *c0, *c1; */
/* ip_adjacency_t *adj0 = 0, *adj1 = 0; */
/* u32 bi0, next0, adj_index0, pass0, save_next0, fib_index0; */
/* u32 bi1, next1, adj_index1, pass1, save_next1, fib_index1; */
/* udp_header_t *udp0, *udp1; */
/* /\* Prefetch next iteration. *\/ */
/* { */
/* vlib_buffer_t *p2, *p3; */
/* p2 = vlib_get_buffer (vm, from[2]); */
/* p3 = vlib_get_buffer (vm, from[3]); */
/* vlib_prefetch_buffer_header (p2, LOAD); */
/* vlib_prefetch_buffer_header (p3, LOAD); */
/* CLIB_PREFETCH (p2->data, sizeof (ip0[0]), LOAD); */
/* CLIB_PREFETCH (p3->data, sizeof (ip1[0]), LOAD); */
/* } */
/* bi0 = to_next[0] = from[0]; */
/* bi1 = to_next[1] = from[1]; */
/* from += 2; */
/* to_next += 2; */
/* n_left_from -= 2; */
/* n_left_to_next -= 2; */
/* b0 = vlib_get_buffer (vm, bi0); */
/* b1 = vlib_get_buffer (vm, bi1); */
/* fib_index0 = */
/* vec_elt (im->fib_index_by_sw_if_index, */
/* vnet_buffer (b0)->sw_if_index[VLIB_RX]); */
/* fib_index1 = */
/* vec_elt (im->fib_index_by_sw_if_index, */
/* vnet_buffer (b1)->sw_if_index[VLIB_RX]); */
/* ip0 = vlib_buffer_get_current (b0); */
/* ip1 = vlib_buffer_get_current (b1); */
/* if (is_tx) */
/* { */
/* c0 = vnet_get_config_data (&tx_cm->config_main, */
/* &b0->current_config_index, */
/* &next0, sizeof (c0[0])); */
/* c1 = vnet_get_config_data (&tx_cm->config_main, */
/* &b1->current_config_index, */
/* &next1, sizeof (c1[0])); */
/* } */
/* else */
/* { */
/* c0 = vnet_get_config_data (&rx_cm->config_main, */
/* &b0->current_config_index, */
/* &next0, sizeof (c0[0])); */
/* c1 = vnet_get_config_data (&rx_cm->config_main, */
/* &b1->current_config_index, */
/* &next1, sizeof (c1[0])); */
/* } */
/* /\* we can't use the default VRF here... *\/ */
/* for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++) */
/* { */
/* ASSERT (c0->fib_index[i] && c1->fib_index[i]); */
/* } */
/* if (is_tx) */
/* { */
/* if (ip0->protocol == IP_PROTOCOL_UDP) */
/* fib_index0 = */
/* c0->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]; */
/* if (ip0->protocol == IP_PROTOCOL_TCP) */
/* fib_index0 = */
/* c0->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]; */
/* } */
/* else */
/* { */
/* if (ip0->protocol == IP_PROTOCOL_UDP) */
/* fib_index0 = */
/* c0->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]; */
/* if (ip0->protocol == IP_PROTOCOL_TCP) */
/* fib_index0 = */
/* c0->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]; */
/* } */
/* if (PREDICT_TRUE (fib_index0 != ~0)) */
/* { */
/* mtrie0 = &vec_elt_at_index (im->fibs, fib_index0)->mtrie; */
/* leaf0 = IP4_FIB_MTRIE_LEAF_ROOT; */
/* leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
/* &ip0->src_address, 0); */
/* leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
/* &ip0->src_address, 1); */
/* leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
/* &ip0->src_address, 2); */
/* leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
/* &ip0->src_address, 3); */
/* adj_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0); */
/* ASSERT (adj_index0 == ip4_fib_lookup_with_table (im, fib_index0, */
/* &ip0->src_address, */
/* 0 */
/* /\* use dflt rt *\/ */
/* )); */
/* adj0 = ip_get_adjacency (lm, adj_index0); */
/* } */
/* if (is_tx) */
/* { */
/* if (ip1->protocol == IP_PROTOCOL_UDP) */
/* fib_index1 = */
/* c1->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]; */
/* if (ip1->protocol == IP_PROTOCOL_TCP) */
/* fib_index1 = */
/* c1->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]; */
/* } */
/* else */
/* { */
/* if (ip1->protocol == IP_PROTOCOL_UDP) */
/* fib_index1 = */
/* c1->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]; */
/* if (ip1->protocol == IP_PROTOCOL_TCP) */
/* fib_index1 = */
/* c1->fib_index */
/* [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]; */
/* } */
/* if (PREDICT_TRUE (fib_index1 != ~0)) */
/* { */
/* mtrie1 = &vec_elt_at_index (im->fibs, fib_index1)->mtrie; */
/* leaf1 = IP4_FIB_MTRIE_LEAF_ROOT; */
/* leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
/* &ip1->src_address, 0); */
/* leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
/* &ip1->src_address, 1); */
/* leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
/* &ip1->src_address, 2); */
/* leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
/* &ip1->src_address, 3); */
/* adj_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1); */
/* ASSERT (adj_index1 == ip4_fib_lookup_with_table (im, fib_index1, */
/* &ip1->src_address, */
/* 0)); */
/* adj1 = ip_get_adjacency (lm, adj_index1); */
/* } */
/* pass0 = 0; */
/* pass0 |= adj0 == 0; */
/* pass0 |= ip4_address_is_multicast (&ip0->src_address); */
/* pass0 |= */
/* ip0->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF); */
/* pass0 |= (ip0->protocol != IP_PROTOCOL_UDP) */
/* && (ip0->protocol != IP_PROTOCOL_TCP); */
/* pass1 = 0; */
/* pass1 |= adj1 == 0; */
/* pass1 |= ip4_address_is_multicast (&ip1->src_address); */
/* pass1 |= */
/* ip1->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF); */
/* pass1 |= (ip1->protocol != IP_PROTOCOL_UDP) */
/* && (ip1->protocol != IP_PROTOCOL_TCP); */
/* save_next0 = next0; */
/* udp0 = ip4_next_header (ip0); */
/* save_next1 = next1; */
/* udp1 = ip4_next_header (ip1); */
/* if (PREDICT_TRUE (pass0 == 0)) */
/* { */
/* good_packets++; */
/* next0 = check_adj_port_range_x1 */
/* (adj0, clib_net_to_host_u16 (udp0->dst_port), next0); */
/* good_packets -= (save_next0 != next0); */
/* b0->error = error_node->errors */
/* [IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL]; */
/* } */
/* if (PREDICT_TRUE (pass1 == 0)) */
/* { */
/* good_packets++; */
/* next1 = check_adj_port_range_x1 */
/* (adj1, clib_net_to_host_u16 (udp1->dst_port), next1); */
/* good_packets -= (save_next1 != next1); */
/* b1->error = error_node->errors */
/* [IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL]; */
/* } */
/* if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) */
/* && (b0->flags & VLIB_BUFFER_IS_TRACED))) */
/* { */
/* ip4_source_and_port_range_check_trace_t *t = */
/* vlib_add_trace (vm, node, b0, sizeof (*t)); */
/* t->pass = next0 == save_next0; */
/* t->bypass = pass0; */
/* t->fib_index = fib_index0; */
/* t->src_addr.as_u32 = ip0->src_address.as_u32; */
/* t->port = (pass0 == 0) ? */
/* clib_net_to_host_u16 (udp0->dst_port) : 0; */
/* t->is_tcp = ip0->protocol == IP_PROTOCOL_TCP; */
/* } */
/* if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) */
/* && (b1->flags & VLIB_BUFFER_IS_TRACED))) */
/* { */
/* ip4_source_and_port_range_check_trace_t *t = */
/* vlib_add_trace (vm, node, b1, sizeof (*t)); */
/* t->pass = next1 == save_next1; */
/* t->bypass = pass1; */
/* t->fib_index = fib_index1; */
/* t->src_addr.as_u32 = ip1->src_address.as_u32; */
/* t->port = (pass1 == 0) ? */
/* clib_net_to_host_u16 (udp1->dst_port) : 0; */
/* t->is_tcp = ip1->protocol == IP_PROTOCOL_TCP; */
/* } */
/* vlib_validate_buffer_enqueue_x2 (vm, node, next_index, */
/* to_next, n_left_to_next, */
/* bi0, bi1, next0, next1); */
/* } */
while (n_left_from > 0 && n_left_to_next > 0)
{
vlib_buffer_t *b0;
ip4_header_t *ip0;
ip_source_and_port_range_check_config_t *c0;
u32 bi0, next0, lb_index0, pass0, save_next0, fib_index0;
udp_header_t *udp0;
const protocol_port_range_dpo_t *ppr_dpo0 = NULL;
const dpo_id_t *dpo;
u32 sw_if_index0;
bi0 = from[0];
to_next[0] = bi0;
from += 1;
to_next += 1;
n_left_from -= 1;
n_left_to_next -= 1;
b0 = vlib_get_buffer (vm, bi0);
sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
if (is_tx)
vlib_buffer_advance (b0, sizeof (ethernet_header_t));
ip0 = vlib_buffer_get_current (b0);
c0 = vnet_feature_next_with_data (&next0, b0, sizeof (c0[0]));
/* we can't use the default VRF here... */
for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
{
ASSERT (c0->fib_index[i]);
}
if (is_tx)
{
if (ip0->protocol == IP_PROTOCOL_UDP)
fib_index0 =
c0->fib_index
[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN];
if (ip0->protocol == IP_PROTOCOL_TCP)
fib_index0 =
c0->fib_index
[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN];
}
else
{
if (ip0->protocol == IP_PROTOCOL_UDP)
fib_index0 =
c0->fib_index
[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT];
if (ip0->protocol == IP_PROTOCOL_TCP)
fib_index0 =
c0->fib_index
[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT];
}
if (fib_index0 != ~0)
{
lb_index0 = ip4_fib_forwarding_lookup (fib_index0,
&ip0->src_address);
dpo =
load_balance_get_bucket_i (load_balance_get (lb_index0), 0);
if (ppr_dpo_type == dpo->dpoi_type)
{
ppr_dpo0 = protocol_port_range_dpo_get (dpo->dpoi_index);
}
/*
* else the lookup hit an enty that was no inserted
* by this range checker, which is the default route
*/
}
/*
* $$$ which (src,dst) categories should we always pass?
*/
pass0 = 0;
pass0 |= ip4_address_is_multicast (&ip0->src_address);
pass0 |=
ip0->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF);
pass0 |= (ip0->protocol != IP_PROTOCOL_UDP)
&& (ip0->protocol != IP_PROTOCOL_TCP);
save_next0 = next0;
udp0 = ip4_next_header (ip0);
if (PREDICT_TRUE (pass0 == 0))
{
good_packets++;
next0 = check_adj_port_range_x1
(ppr_dpo0, clib_net_to_host_u16 (udp0->dst_port), next0);
good_packets -= (save_next0 != next0);
b0->error = error_node->errors
[IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL];
}
if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
&& (b0->flags & VLIB_BUFFER_IS_TRACED)))
{
ip4_source_and_port_range_check_trace_t *t =
vlib_add_trace (vm, node, b0, sizeof (*t));
t->pass = next0 == save_next0;
t->bypass = pass0;
t->fib_index = fib_index0;
t->src_addr.as_u32 = ip0->src_address.as_u32;
t->port = (pass0 == 0) ?
clib_net_to_host_u16 (udp0->dst_port) : 0;
t->is_tcp = ip0->protocol == IP_PROTOCOL_TCP;
}
if (is_tx)
vlib_buffer_advance (b0, -sizeof (ethernet_header_t));
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
to_next, n_left_to_next,
bi0, next0);
}
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
if (is_tx)
vlib_node_increment_counter (vm, ip4_source_port_and_range_check_tx.index,
IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_OK,
good_packets);
else
vlib_node_increment_counter (vm, ip4_source_port_and_range_check_rx.index,
IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_OK,
good_packets);
return frame->n_vectors;
}
static uword
ip4_source_and_port_range_check_rx (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
return ip4_source_and_port_range_check_inline (vm, node, frame,
0 /* !is_tx */ );
}
static uword
ip4_source_and_port_range_check_tx (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
return ip4_source_and_port_range_check_inline (vm, node, frame,
1 /* is_tx */ );
}
/* Note: Calling same function for both RX and TX nodes
as always checking dst_port, although
if this changes can easily make new function
*/
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (ip4_source_port_and_range_check_rx) = {
.function = ip4_source_and_port_range_check_rx,
.name = "ip4-source-and-port-range-check-rx",
.vector_size = sizeof (u32),
.n_errors = ARRAY_LEN(ip4_source_and_port_range_check_error_strings),
.error_strings = ip4_source_and_port_range_check_error_strings,
.n_next_nodes = IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
.next_nodes = {
[IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP] = "ip4-drop",
},
.format_buffer = format_ip4_header,
.format_trace = format_ip4_source_and_port_range_check_trace,
};
/* *INDENT-ON* */
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (ip4_source_port_and_range_check_tx) = {
.function = ip4_source_and_port_range_check_tx,
.name = "ip4-source-and-port-range-check-tx",
.vector_size = sizeof (u32),
.n_errors = ARRAY_LEN(ip4_source_and_port_range_check_error_strings),
.error_strings = ip4_source_and_port_range_check_error_strings,
.n_next_nodes = IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
.next_nodes = {
[IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP] = "ip4-drop",
},
.format_buffer = format_ip4_header,
.format_trace = format_ip4_source_and_port_range_check_trace,
};
/* *INDENT-ON* */
int
set_ip_source_and_port_range_check (vlib_main_t * vm,
u32 * fib_index,
u32 sw_if_index, u32 is_add)
{
ip_source_and_port_range_check_config_t config;
int rv = 0;
int i;
for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
{
config.fib_index[i] = fib_index[i];
}
/* For OUT we are in the RX path */
if ((fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT] != ~0) ||
(fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT] != ~0))
{
vnet_feature_enable_disable ("ip4-unicast",
"ip4-source-and-port-range-check-rx",
sw_if_index, is_add, &config,
sizeof (config));
}
/* For IN we are in the TX path */
if ((fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN] != ~0) ||
(fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN] != ~0))
{
vnet_feature_enable_disable ("ip4-output",
"ip4-source-and-port-range-check-tx",
sw_if_index, is_add, &config,
sizeof (config));
}
return rv;
}
static clib_error_t *
set_ip_source_and_port_range_check_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
vnet_main_t *vnm = vnet_get_main ();
ip4_main_t *im = &ip4_main;
clib_error_t *error = 0;
u8 is_add = 1;
u32 sw_if_index = ~0;
u32 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
u32 fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
int vrf_set = 0;
uword *p;
int rv = 0;
int i;
sw_if_index = ~0;
for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
{
fib_index[i] = ~0;
vrf_id[i] = ~0;
}
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "%U", unformat_vnet_sw_interface, vnm,
&sw_if_index))
;
else
if (unformat
(input, "tcp-out-vrf %d",
&vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]))
vrf_set = 1;
else
if (unformat
(input, "udp-out-vrf %d",
&vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]))
vrf_set = 1;
else
if (unformat
(input, "tcp-in-vrf %d",
&vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]))
vrf_set = 1;
else
if (unformat
(input, "udp-in-vrf %d",
&vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]))
vrf_set = 1;
else if (unformat (input, "del"))
is_add = 0;
else
break;
}
if (sw_if_index == ~0)
return clib_error_return (0, "Interface required but not specified");
if (!vrf_set)
return clib_error_return (0,
"TCP or UDP VRF ID required but not specified");
for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
{
if (vrf_id[i] == 0)
return clib_error_return (0,
"TCP, UDP VRF ID should not be 0 (default). Should be distinct VRF for this purpose. ");
if (vrf_id[i] != ~0)
{
p = hash_get (im->fib_index_by_table_id, vrf_id[i]);
if (p == 0)
return clib_error_return (0, "Invalid VRF ID %d", vrf_id[i]);
fib_index[i] = p[0];
}
}
rv =
set_ip_source_and_port_range_check (vm, fib_index, sw_if_index, is_add);
switch (rv)
{
case 0:
break;
default:
return clib_error_return
(0,
"set source and port-range on interface returned an unexpected value: %d",
rv);
}
return error;
}
/*?
* Add the 'ip4-source-and-port-range-check-rx' or
* 'ip4-source-and-port-range-check-tx' graph node for a given
* interface. 'tcp-out-vrf' and 'udp-out-vrf' will add to
* the RX path. 'tcp-in-vrf' and 'udp-in-vrf' will add to
* the TX path. A graph node will be inserted into the chain when
* the range check is added to the first interface. It will not
* be removed from when range check is removed from the last
* interface.
*
* By adding the range check graph node to the interface, incoming
* or outgoing TCP/UDP packets will be validated using the
* provided IPv4 FIB table (VRF).
*
* @note 'ip4-source-and-port-range-check-rx' and
* 'ip4-source-and-port-range-check-tx' strings are too long, so
* they are truncated on the 'show vlib graph' output.
*
* @todo This content needs to be validated and potentially more detail added.
*
* @cliexpar
* @parblock
* Example of graph node before range checking is enabled:
* @cliexstart{show vlib graph ip4-source-and-port-range-check-tx}
* Name Next Previous
* ip4-source-and-port-range- ip4-drop [0]
* @cliexend
*
* Example of how to enable range checking on TX:
* @cliexcmd{set interface ip source-and-port-range-check GigabitEthernet2/0/0 udp-in-vrf 7}
*
* Example of graph node after range checking is enabled:
* @cliexstart{show vlib graph ip4-source-and-port-range-check-tx}
* Name Next Previous
* ip4-source-and-port-range- ip4-drop [0] ip4-rewrite
* interface-output [1]
* @cliexend
*
* Example of how to display the features enabed on an interface:
* @cliexstart{show ip interface features GigabitEthernet2/0/0}
* IP feature paths configured on GigabitEthernet2/0/0...
*
* ipv4 unicast:
* ip4-source-and-port-range-check-rx
* ip4-lookup
*
* ipv4 multicast:
* ip4-lookup-multicast
*
* ipv4 multicast:
* interface-output
*
* ipv6 unicast:
* ip6-lookup
*
* ipv6 multicast:
* ip6-lookup
*
* ipv6 multicast:
* interface-output
* @cliexend
* @endparblock
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (set_interface_ip_source_and_port_range_check_command, static) = {
.path = "set interface ip source-and-port-range-check",
.function = set_ip_source_and_port_range_check_fn,
.short_help = "set interface ip source-and-port-range-check <interface> [tcp-out-vrf <table-id>] [udp-out-vrf <table-id>] [tcp-in-vrf <table-id>] [udp-in-vrf <table-id>] [del]",
};
/* *INDENT-ON* */
static u8 *
format_ppr_dpo (u8 * s, va_list * args)
{
index_t index = va_arg (*args, index_t);
CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
protocol_port_range_dpo_t *ppr_dpo;
int i, j;
int printed = 0;
ppr_dpo = protocol_port_range_dpo_get (index);
s = format (s, "allow ");
for (i = 0; i < ppr_dpo->n_used_blocks; i++)
{
for (j = 0; j < 8; j++)
{
if (ppr_dpo->blocks[i].low.as_u16[j])
{
if (printed)
s = format (s, ", ");
if (ppr_dpo->blocks[i].hi.as_u16[j] >
(ppr_dpo->blocks[i].low.as_u16[j] + 1))
s =
format (s, "%d-%d", (u32) ppr_dpo->blocks[i].low.as_u16[j],
(u32) ppr_dpo->blocks[i].hi.as_u16[j] - 1);
else
s = format (s, "%d", ppr_dpo->blocks[i].low.as_u16[j]);
printed = 1;
}
}
}
return s;
}
static void
ppr_dpo_lock (dpo_id_t * dpo)
{
}
static void
ppr_dpo_unlock (dpo_id_t * dpo)
{
}
const static dpo_vft_t ppr_vft = {
.dv_lock = ppr_dpo_lock,
.dv_unlock = ppr_dpo_unlock,
.dv_format = format_ppr_dpo,
};
const static char *const ppr_ip4_nodes[] = {
"ip4-source-and-port-range-check-rx",
NULL,
};
const static char *const *const ppr_nodes[DPO_PROTO_NUM] = {
[DPO_PROTO_IP4] = ppr_ip4_nodes,
};
clib_error_t *
ip4_source_and_port_range_check_init (vlib_main_t * vm)
{
source_range_check_main_t *srm = &source_range_check_main;
srm->vlib_main = vm;
srm->vnet_main = vnet_get_main ();
ppr_dpo_type = dpo_register_new_type (&ppr_vft, ppr_nodes);
return 0;
}
VLIB_INIT_FUNCTION (ip4_source_and_port_range_check_init);
protocol_port_range_dpo_t *
protocol_port_range_dpo_alloc (void)
{
protocol_port_range_dpo_t *ppr_dpo;
pool_get_aligned (ppr_dpo_pool, ppr_dpo, CLIB_CACHE_LINE_BYTES);
memset (ppr_dpo, 0, sizeof (*ppr_dpo));
ppr_dpo->n_free_ranges = N_PORT_RANGES_PER_DPO;
return (ppr_dpo);
}
static int
add_port_range_adjacency (u32 fib_index,
ip4_address_t * address,
u32 length, u16 * low_ports, u16 * high_ports)
{
protocol_port_range_dpo_t *ppr_dpo;
dpo_id_t dpop = DPO_INVALID;
int i, j, k;
fib_node_index_t fei;
fib_prefix_t pfx = {
.fp_proto = FIB_PROTOCOL_IP4,
.fp_len = length,
.fp_addr = {
.ip4 = *address,
},
};
/*
* check to see if we have already sourced this prefix
*/
fei = fib_table_lookup_exact_match (fib_index, &pfx);
if (FIB_NODE_INDEX_INVALID == fei)
{
/*
* this is a first time add for this prefix.
*/
ppr_dpo = protocol_port_range_dpo_alloc ();
}
else
{
/*
* the prefix is already there.
* check it was sourced by us, and if so get the ragne DPO from it.
*/
dpo_id_t dpo = DPO_INVALID;
const dpo_id_t *bucket;
if (fib_entry_get_dpo_for_source (fei, FIB_SOURCE_SPECIAL, &dpo))
{
/*
* there is existing state. we'll want to add the new ranges to it
*/
bucket =
load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
dpo_reset (&dpo);
}
else
{
/*
* there is no PPR state associated with this prefix,
* so we'll need a new DPO
*/
ppr_dpo = protocol_port_range_dpo_alloc ();
}
}
if (vec_len (low_ports) > ppr_dpo->n_free_ranges)
return VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY;
j = k = 0;
for (i = 0; i < vec_len (low_ports); i++)
{
for (; j < N_BLOCKS_PER_DPO; j++)
{
for (; k < 8; k++)
{
if (ppr_dpo->blocks[j].low.as_u16[k] == 0)
{
ppr_dpo->blocks[j].low.as_u16[k] = low_ports[i];
ppr_dpo->blocks[j].hi.as_u16[k] = high_ports[i];
goto doublebreak;
}
}
}
doublebreak:;
}
ppr_dpo->n_used_blocks = j + 1;
/*
* add or update the entry in the FIB
*/
dpo_set (&dpop, ppr_dpo_type, DPO_PROTO_IP4, (ppr_dpo - ppr_dpo_pool));
if (FIB_NODE_INDEX_INVALID == fei)
{
fib_table_entry_special_dpo_add (fib_index,
&pfx,
FIB_SOURCE_SPECIAL,
FIB_ENTRY_FLAG_NONE, &dpop);
}
else
{
fib_entry_special_update (fei,
FIB_SOURCE_SPECIAL,
FIB_ENTRY_FLAG_NONE, &dpop);
}
return 0;
}
static int
remove_port_range_adjacency (u32 fib_index,
ip4_address_t * address,
u32 length, u16 * low_ports, u16 * high_ports)
{
protocol_port_range_dpo_t *ppr_dpo;
fib_node_index_t fei;
int i, j, k;
fib_prefix_t pfx = {
.fp_proto = FIB_PROTOCOL_IP4,
.fp_len = length,
.fp_addr = {
.ip4 = *address,
},
};
/*
* check to see if we have sourced this prefix
*/
fei = fib_table_lookup_exact_match (fib_index, &pfx);
if (FIB_NODE_INDEX_INVALID == fei)
{
/*
* not one of ours
*/
return VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE;
}
else
{
/*
* the prefix is already there.
* check it was sourced by us
*/
dpo_id_t dpo = DPO_INVALID;
const dpo_id_t *bucket;
if (fib_entry_get_dpo_for_source (fei, FIB_SOURCE_SPECIAL, &dpo))
{
/*
* there is existing state. we'll want to add the new ranges to it
*/
bucket =
load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
dpo_reset (&dpo);
}
else
{
/*
* not one of ours
*/
return VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE;
}
}
for (i = 0; i < vec_len (low_ports); i++)
{
for (j = 0; j < N_BLOCKS_PER_DPO; j++)
{
for (k = 0; k < 8; k++)
{
if (low_ports[i] == ppr_dpo->blocks[j].low.as_u16[k] &&
high_ports[i] == ppr_dpo->blocks[j].hi.as_u16[k])
{
ppr_dpo->blocks[j].low.as_u16[k] =
ppr_dpo->blocks[j].hi.as_u16[k] = 0;
goto doublebreak;
}
}
}
doublebreak:;
}
ppr_dpo->n_free_ranges = 0;
/* Have we deleted all ranges yet? */
for (i = 0; i < N_BLOCKS_PER_DPO; i++)
{
for (j = 0; j < 8; j++)
{
if (ppr_dpo->blocks[j].low.as_u16[i] == 0)
ppr_dpo->n_free_ranges++;
}
}
if (N_PORT_RANGES_PER_DPO == ppr_dpo->n_free_ranges)
{
/* Yes, lose the adjacency... */
fib_table_entry_special_remove (fib_index, &pfx, FIB_SOURCE_SPECIAL);
}
else
{
/*
* compact the ranges down to a contiguous block
*/
// FIXME. TODO.
}
return 0;
}
// This will be moved to another file and implemented post API freeze.
int
ip6_source_and_port_range_check_add_del (ip6_address_t * address,
u32 length,
u32 vrf_id,
u16 * low_ports,
u16 * high_ports, int is_add)
{
u32 fib_index;
fib_index = fib_table_find (FIB_PROTOCOL_IP4, vrf_id);
ASSERT (~0 != fib_index);
fib_table_unlock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_CLASSIFY);
return 0;
}
int
ip4_source_and_port_range_check_add_del (ip4_address_t * address,
u32 length,
u32 vrf_id,
u16 * low_ports,
u16 * high_ports, int is_add)
{
u32 fib_index;
fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, vrf_id,
FIB_SOURCE_CLASSIFY);
if (is_add == 0)
{
remove_port_range_adjacency (fib_index, address, length,
low_ports, high_ports);
}
else
{
add_port_range_adjacency (fib_index, address, length,
low_ports, high_ports);
}
return 0;
}
static clib_error_t *
ip_source_and_port_range_check_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
u16 *low_ports = 0;
u16 *high_ports = 0;
u16 this_low;
u16 this_hi;
ip4_address_t ip4_addr;
ip6_address_t ip6_addr; //This function will be moved to generic impl when v6 done.
u32 length;
u32 tmp, tmp2;
u32 vrf_id = ~0;
int is_add = 1, ip_ver = ~0;
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
ip_ver = 4;
else
if (unformat
(input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
ip_ver = 6;
else if (unformat (input, "vrf %d", &vrf_id))
;
else if (unformat (input, "del"))
is_add = 0;
else if (unformat (input, "port %d", &tmp))
{
if (tmp == 0 || tmp > 65535)
return clib_error_return (0, "port %d out of range", tmp);
this_low = tmp;
this_hi = this_low + 1;
vec_add1 (low_ports, this_low);
vec_add1 (high_ports, this_hi);
}
else if (unformat (input, "range %d - %d", &tmp, &tmp2))
{
if (tmp > tmp2)
return clib_error_return (0, "ports %d and %d out of order",
tmp, tmp2);
if (tmp == 0 || tmp > 65535)
return clib_error_return (0, "low port %d out of range", tmp);
if (tmp2 == 0 || tmp2 > 65535)
return clib_error_return (0, "high port %d out of range", tmp2);
this_low = tmp;
this_hi = tmp2 + 1;
vec_add1 (low_ports, this_low);
vec_add1 (high_ports, this_hi);
}
else
break;
}
if (ip_ver == ~0)
return clib_error_return (0, " <address>/<mask> not specified");
if (vrf_id == ~0)
return clib_error_return (0, " VRF ID required, not specified");
if (vec_len (low_ports) == 0)
return clib_error_return (0,
" Both VRF ID and range/port must be set for a protocol.");
if (vrf_id == 0)
return clib_error_return (0, " VRF ID can not be 0 (default).");
if (ip_ver == 4)
rv = ip4_source_and_port_range_check_add_del
(&ip4_addr, length, vrf_id, low_ports, high_ports, is_add);
else
return clib_error_return (0, " IPv6 in subsequent patch");
switch (rv)
{
case 0:
break;
case VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE:
return clib_error_return
(0, " Incorrect adjacency for add/del operation");
case VNET_API_ERROR_EXCEEDED_NUMBER_OF_PORTS_CAPACITY:
return clib_error_return (0, " Too many ports in add/del operation");
case VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY:
return clib_error_return
(0, " Too many ranges requested for add operation");
default:
return clib_error_return (0, " returned an unexpected value: %d", rv);
}
return 0;
}
/*?
* This command adds an IP Subnet and range of ports to be validated
* by an IP FIB table (VRF).
*
* @todo This is incomplete. This needs a detailed description and a
* practical example.
*
* @cliexpar
* Example of how to add an IPv4 subnet and single port to an IPv4 FIB table:
* @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 port 23}
* Example of how to add an IPv4 subnet and range of ports to an IPv4 FIB table:
* @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 range 23 - 100}
* Example of how to delete an IPv4 subnet and single port from an IPv4 FIB table:
* @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 port 23 del}
* Example of how to delete an IPv4 subnet and range of ports from an IPv4 FIB table:
* @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 range 23 - 100 del}
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (ip_source_and_port_range_check_command, static) = {
.path = "set ip source-and-port-range-check",
.function = ip_source_and_port_range_check_command_fn,
.short_help =
"set ip source-and-port-range-check vrf <table-id> <ip-addr>/<mask> {port nn | range <nn> - <nn>} [del]",
};
/* *INDENT-ON* */
static clib_error_t *
show_source_and_port_range_check_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
protocol_port_range_dpo_t *ppr_dpo;
u32 fib_index;
u8 addr_set = 0;
u32 vrf_id = ~0;
int rv, i, j;
u32 port = 0;
fib_prefix_t pfx = {
.fp_proto = FIB_PROTOCOL_IP4,
.fp_len = 32,
};
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
addr_set = 1;
else if (unformat (input, "vrf %d", &vrf_id))
;
else if (unformat (input, "port %d", &port))
;
else
break;
}
if (addr_set == 0)
return clib_error_return (0, "<address> not specified");
if (vrf_id == ~0)
return clib_error_return (0, "VRF ID required, not specified");
fib_index = fib_table_find (FIB_PROTOCOL_IP4, vrf_id);
if (~0 == fib_index)
return clib_error_return (0, "VRF %d not found", vrf_id);
/*
* find the longest prefix match on the address requested,
* check it was sourced by us
*/
dpo_id_t dpo = DPO_INVALID;
const dpo_id_t *bucket;
if (!fib_entry_get_dpo_for_source (fib_table_lookup (fib_index, &pfx),
FIB_SOURCE_SPECIAL, &dpo))
{
/*
* not one of ours
*/
vlib_cli_output (vm, "%U: src address drop", format_ip4_address,
&pfx.fp_addr.ip4);
return 0;
}
bucket = load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
dpo_reset (&dpo);
if (port)
{
rv = check_adj_port_range_x1 (ppr_dpo, (u16) port, 1234);
if (rv == 1234)
vlib_cli_output (vm, "%U port %d PASS", format_ip4_address,
&pfx.fp_addr.ip4, port);
else
vlib_cli_output (vm, "%U port %d FAIL", format_ip4_address,
&pfx.fp_addr.ip4, port);
return 0;
}
else
{
u8 *s;
s = format (0, "%U: ", format_ip4_address, &pfx.fp_addr.ip4);
for (i = 0; i < N_BLOCKS_PER_DPO; i++)
{
for (j = 0; j < 8; j++)
{
if (ppr_dpo->blocks[i].low.as_u16[j])
s = format (s, "%d - %d ",
(u32) ppr_dpo->blocks[i].low.as_u16[j],
(u32) ppr_dpo->blocks[i].hi.as_u16[j]);
}
}
vlib_cli_output (vm, "%s", s);
vec_free (s);
}
return 0;
}
/*?
* Display the range of ports being validated by an IPv4 FIB for a given
* IP or subnet, or test if a given IP and port are being validated.
*
* @todo This is incomplete. This needs a detailed description and a
* practical example.
*
* @cliexpar
* Example of how to display the set of ports being validated for a given
* IPv4 subnet:
* @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.0}
* 172.16.2.0: 23 - 101
* @cliexend
* Example of how to test to determine of a given Pv4 address and port
* are being validated:
* @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.2 port 23}
* 172.16.2.2 port 23 PASS
* @cliexend
* @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.2 port 250}
* 172.16.2.2 port 250 FAIL
* @cliexend
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_source_and_port_range_check, static) = {
.path = "show ip source-and-port-range-check",
.function = show_source_and_port_range_check_fn,
.short_help =
"show ip source-and-port-range-check vrf <table-id> <ip-addr> [port <n>]",
};
/* *INDENT-ON* */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
|
60956.c | #include "all.h"
static int get(char* w, int i) {
if (i < 0) i += WORLD_SIZE;
return w[i % WORLD_SIZE];
}
void update(char* rule) {
char world1[WORLD_SIZE];
for (int i = 0; i < WORLD_SIZE; i++) {
int j = get(world, i - 1) << 2 | get(world, i) << 1 | get(world, i + 1);
world1[i] = rule[j];
}
memcpy(world, world1, sizeof world1);
}
|
517926.c | /*
* Copyright (c) 1987-1993, The University of Utah and
* the Center for Software Science at the University of Utah (CSS).
* All rights reserved.
*
* Permission to use, copy, modify and distribute this software is hereby
* granted provided that (1) source code retains these copyright, permission,
* and disclaimer notices, and (2) redistributions including binaries
* reproduce the notices in supporting documentation, and (3) all advertising
* materials mentioning features or use of this software display the following
* acknowledgement: ``This product includes software developed by the Center
* for Software Science at the University of Utah.''
*
* THE UNIVERSITY OF UTAH AND CSS ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
* IS" CONDITION. THE UNIVERSITY OF UTAH AND CSS DISCLAIM ANY LIABILITY OF
* ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* CSS requests users of this software to return to [email protected] any
* improvements that they make and grant CSS redistribution rights.
*
* from: Utah $Hdr: grfinfo.c 1.3 94/04/04$
* $NetBSD: grfinfo.c,v 1.6 1997/10/17 15:44:08 carrel Exp $
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: grfinfo.c,v 1.6 1997/10/17 15:44:08 carrel Exp $");
#endif
#include <sys/types.h>
#include <sys/ioctl.h>
#include <dev/grfioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int aflg = 0;
int tflg = 0;
char *dname;
struct grfinfo gi;
struct grf_info {
int grf_id;
char *grf_name;
} info[] = {
{ GRFGATOR, "gatorbox" },
{ GRFBOBCAT, "topcat" },
{ GRFRBOX, "renaissance" },
{ GRFFIREEYE, "fireeye" },
{ GRFHYPERION, "hyperion" },
{ GRFDAVINCI, "davinci" },
{ -1, "unknown" }
};
void getinfo __P((void));
int main __P((int, char **));
void printall __P((void));
char *tname __P((void));
void usage __P((void));
int
main(argc, argv)
int argc;
char **argv;
{
int c;
while ((c = getopt(argc, argv, "at")) != EOF)
switch (c) {
/* everything */
case 'a':
aflg++;
break;
/* type */
case 't':
tflg++;
break;
/* bogon */
case '?':
usage();
}
if (optind == argc)
usage();
dname = argv[optind];
getinfo();
if (aflg)
printall();
else
printf("%s\n", tname());
exit(0);
}
void
getinfo()
{
int f;
f = open(dname, 0);
if (f < 0 || ioctl(f, GRFIOCGINFO, &gi) < 0) {
if (tflg)
printf("none\n");
else
perror(dname);
exit(1);
}
close(f);
}
void
printall()
{
printf("%s: %d x %d ", dname, gi.gd_dwidth, gi.gd_dheight);
if (gi.gd_colors < 3)
printf("monochrome");
else {
printf("%d color", gi.gd_colors);
if (gi.gd_planes)
printf(", %d plane", gi.gd_planes);
}
printf(" %s\n", tname());
printf("registers: 0x%x bytes at %p\n",
gi.gd_regsize, gi.gd_regaddr);
printf("framebuf: 0x%x bytes at %p (%d x %d)\n",
gi.gd_fbsize, gi.gd_fbaddr, gi.gd_fbwidth, gi.gd_fbheight);
}
char *
tname()
{
struct grf_info *gp;
for (gp = info; gp->grf_id >= 0; gp++)
if (gi.gd_id == gp->grf_id)
break;
/*
* Heuristics to differentiate catseye from topcat:
* low-res color catseye has 1k x 1k framebuffer and 64 colors
* hi-res mono and color catseye have 1280 wide display
*/
if (gi.gd_id == GRFBOBCAT &&
(gi.gd_dwidth == 1280 ||
(gi.gd_fbsize == 0x100000 && gi.gd_colors == 64)))
return("catseye");
return(gp->grf_name);
}
void
usage()
{
extern char *__progname; /* from crt0.o */
fprintf(stderr, "usage: %s [-at] device\n", __progname);
exit(1);
}
|
82143.c | #include <img.h>
#include <util.h>
#include <types.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL.h>
SDL_Texture * le_tex(const le_str file, SDL_Renderer * renderer) {
SDL_Surface * surf = IMG_Load(file);
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surf);
if (texture == NULL) { le_print_error("Error Loading Texture: %s", file); }
free(surf);
return texture;
}
|
881385.c | /*************************************************************************
**
** OLE 2 Sample Code
**
** linking.c
**
** This file contains the major interfaces, methods and related support
** functions for implementing linking to items. The code
** contained in this file is used by BOTH the Container and Server
** (Object) versions of the Outline sample code.
**
** As a server SVROUTL supports linking to the whole document object
** (either a file-based document or as an embedded object). It also
** supports linking to ranges (or PseudoObjects).
**
** As a container CNTROUTL supports linking to embedded objects.
** (see file svrpsobj.c for Pseudo Object implementation)
**
** OleDoc Object
** exposed interfaces:
** IPersistFile
** IOleItemContainer
** IExternalConnection
**
** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
**
*************************************************************************/
#include "outline.h"
OLEDBGDATA
extern LPOUTLINEAPP g_lpApp;
STDMETHODIMP OleDoc_ItemCont_GetObjectA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR*lplpvObject
);
STDMETHODIMP OleDoc_ItemCont_GetObjectStorageA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR*lplpvStorage
);
#if defined(OLE_CNTR)
STDMETHODIMP OleDoc_ItemCont_IsRunningA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem
);
HRESULT ContainerDoc_IsRunningA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem);
HRESULT ContainerDoc_GetObjectA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR*lplpvObject
);
HRESULT ContainerDoc_GetObjectStorageA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
LPSTORAGE FAR*lplpStg);
#endif // OLE_CNTR
#if defined(OLE_SERVER)
HRESULT ServerDoc_IsRunningA(LPSERVERDOC lpServerDoc, LPSTR lpszItem);
HRESULT ServerDoc_GetObjectA(
LPSERVERDOC lpServerDoc,
LPSTR lpszItem,
REFIID riid,
LPVOID FAR*lplpvObject);
#endif // OLE_SERVER
/*************************************************************************
** OleDoc::IPersistFile interface implementation
*************************************************************************/
// IPersistFile::QueryInterface
STDMETHODIMP OleDoc_PFile_QueryInterface(
LPPERSISTFILE lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IPersistFile::AddRef
STDMETHODIMP_(ULONG) OleDoc_PFile_AddRef(LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IPersistFile");
return OleDoc_AddRef(lpOleDoc);
}
// IPersistFile::Release
STDMETHODIMP_(ULONG) OleDoc_PFile_Release (LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IPersistFile");
return OleDoc_Release(lpOleDoc);
}
// IPersistFile::GetClassID
STDMETHODIMP OleDoc_PFile_GetClassID (
LPPERSISTFILE lpThis,
CLSID FAR* lpclsid
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
OleDbgOut2("OleDoc_PFile_GetClassID\r\n");
#if defined( OLE_SERVER ) && defined( SVR_TREATAS )
/* OLE2NOTE: we must be carefull to return the correct CLSID here.
** if we are currently preforming a "TreatAs (aka. ActivateAs)"
** operation then we need to return the class of the object
** written in the storage of the object. otherwise we would
** return our own class id.
*/
return ServerDoc_GetClassID((LPSERVERDOC)lpOleDoc, lpclsid);
#else
*lpclsid = CLSID_APP;
#endif
return NOERROR;
}
// IPersistFile::IsDirty
STDMETHODIMP OleDoc_PFile_IsDirty(LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgOut2("OleDoc_PFile_IsDirty\r\n");
if (OutlineDoc_IsModified((LPOUTLINEDOC)lpOleDoc))
return NOERROR;
else
return ResultFromScode(S_FALSE);
}
// IPersistFile::Load
STDMETHODIMP OleDoc_PFile_LoadA(
LPPERSISTFILE lpThis,
LPCSTR lpszFileName,
DWORD grfMode
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
SCODE sc;
OLEDBG_BEGIN2("OleDoc_PFile_Load\r\n")
/* OLE2NOTE: grfMode passed from the caller indicates if the caller
** needs Read or ReadWrite permissions. if appropriate the
** callee should open the file with the requested permissions.
** the caller will normally not impose sharing permissions.
**
** the sample code currently always opens its file ReadWrite.
*/
if (OutlineDoc_LoadFromFile((LPOUTLINEDOC)lpOleDoc, (LPSTR)lpszFileName))
sc = S_OK;
else
sc = E_FAIL;
OLEDBG_END2
return ResultFromScode(sc);
}
// IPersistFile::Load
STDMETHODIMP OleDoc_PFile_Load (
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName,
DWORD grfMode
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_LoadA(lpThis, lpsz, grfMode);
FREESTR(lpsz)
return hr;
}
// IPersistFile::Save
STDMETHODIMP OleDoc_PFile_SaveA (
LPPERSISTFILE lpThis,
LPCSTR lpszFileName,
BOOL fRemember
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
SCODE sc;
OLEDBG_BEGIN2("OleDoc_PFile_Save\r\n")
/* OLE2NOTE: it is only legal to perform a Save or SaveAs operation
** on a file-based document. if the document is an embedded
** object then we can not be changed to a file-base object.
**
** fRemember lpszFileName Type of Save
** ----------------------------------------------
** TRUE NULL SAVE
** TRUE ! NULL SAVE AS
** FALSE ! NULL SAVE COPY AS
** FALSE NULL ***error***
*/
if ( (lpszFileName==NULL || (lpszFileName != NULL && fRemember))
&& ((lpOutlineDoc->m_docInitType != DOCTYPE_FROMFILE
&& lpOutlineDoc->m_docInitType != DOCTYPE_NEW)) ) {
OLEDBG_END2
return ResultFromScode(E_INVALIDARG);
}
if (OutlineDoc_SaveToFile(
(LPOUTLINEDOC)lpOleDoc,
lpszFileName,
lpOutlineDoc->m_cfSaveFormat,
fRemember)) {
sc = S_OK;
} else
sc = E_FAIL;
OLEDBG_END2
return ResultFromScode(sc);
}
// IPersistFile::Save
STDMETHODIMP OleDoc_PFile_Save(
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName,
BOOL fRemember
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_SaveA(lpThis, lpsz, fRemember);
FREESTR(lpsz)
return hr;
}
// IPersistFile::SaveCompleted
STDMETHODIMP OleDoc_PFile_SaveCompletedA (
LPPERSISTFILE lpThis,
LPCSTR lpszFileName
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
OleDbgOut2("OleDoc_PFile_SaveCompleted\r\n");
/* This method is called after IPersistFile::Save is called. during
** the period between Save and SaveCompleted the object must
** consider itself in NOSCRIBBLE mode (ie. it is NOT allowed to
** write to its file. here the object can clear its NOSCRIBBLE
** mode flag. the outline app never scribbles to its storage, so
** we have nothing to do.
*/
return NOERROR;
}
STDMETHODIMP OleDoc_PFile_SaveCompleted (
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_SaveCompletedA(lpThis, lpsz);
FREESTR(lpsz)
return hr;
}
// IPersistFile::GetCurFile
STDMETHODIMP OleDoc_PFile_GetCurFileA (
LPPERSISTFILE lpThis,
LPSTR FAR* lplpszFileName
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
LPMALLOC lpMalloc;
LPSTR lpsz;
SCODE sc;
OleDbgOut2("OleDoc_PFile_GetCurFile\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpszFileName = NULL;
/*********************************************************************
** OLE2NOTE: memory returned for the lplpszFileName must be
** allocated appropriately using the current registered IMalloc
** interface. the allows the ownership of the memory to be
** passed to the caller (even if in another process).
*********************************************************************/
CoGetMalloc(MEMCTX_TASK, &lpMalloc);
if (! lpMalloc) {
return ResultFromScode(E_FAIL);
}
if (lpOutlineDoc->m_docInitType == DOCTYPE_FROMFILE) {
/* valid filename associated; return file name */
lpsz = (LPSTR)lpMalloc->lpVtbl->Alloc(
lpMalloc,
lstrlen((LPSTR)lpOutlineDoc->m_szFileName)+1
);
if (! lpsz) {
sc = E_OUTOFMEMORY;
goto error;
}
lstrcpy(lpsz, (LPSTR)lpOutlineDoc->m_szFileName);
sc = S_OK;
} else {
/* no file associated; return default file name prompt */
lpsz=(LPSTR)lpMalloc->lpVtbl->Alloc(lpMalloc, sizeof(DEFEXTENSION)+3);
wsprintf(lpsz, "*.%s", DEFEXTENSION);
sc = S_FALSE;
}
error:
OleStdRelease((LPUNKNOWN)lpMalloc);
*lplpszFileName = lpsz;
return ResultFromScode(sc);
}
STDMETHODIMP OleDoc_PFile_GetCurFile (
LPPERSISTFILE lpThis,
LPOLESTR FAR* lplpszFileName
)
{
LPSTR lpsz;
HRESULT hr = OleDoc_PFile_GetCurFileA(lpThis, &lpsz);
CopyAndFreeSTR(lpsz, lplpszFileName);
return hr;
}
/*************************************************************************
** OleDoc::IOleItemContainer interface implementation
*************************************************************************/
// IOleItemContainer::QueryInterface
STDMETHODIMP OleDoc_ItemCont_QueryInterface(
LPOLEITEMCONTAINER lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IOleItemContainer::AddRef
STDMETHODIMP_(ULONG) OleDoc_ItemCont_AddRef(LPOLEITEMCONTAINER lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IOleItemContainer");
return OleDoc_AddRef((LPOLEDOC)lpOleDoc);
}
// IOleItemContainer::Release
STDMETHODIMP_(ULONG) OleDoc_ItemCont_Release(LPOLEITEMCONTAINER lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IOleItemContainer");
return OleDoc_Release((LPOLEDOC)lpOleDoc);
}
// IOleItemContainer::ParseDisplayName
STDMETHODIMP OleDoc_ItemCont_ParseDisplayNameA(
LPOLEITEMCONTAINER lpThis,
LPBC lpbc,
LPSTR lpszDisplayName,
ULONG FAR* lpchEaten,
LPMONIKER FAR* lplpmkOut
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
char szItemName[MAXNAMESIZE];
LPUNKNOWN lpUnk;
HRESULT hrErr;
OleDbgOut2("OleDoc_ItemCont_ParseDisplayName\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpmkOut = NULL;
*lpchEaten = OleStdGetItemToken(
lpszDisplayName,
szItemName,
sizeof(szItemName)
);
/* OLE2NOTE: get a pointer to a running instance of the object. we
** should force the object to go running if necessary (even if
** this means launching its server EXE). this is the meaining of
** BINDSPEED_INDEFINITE. Parsing a Moniker is known to be an
** "EXPENSIVE" operation.
*/
hrErr = OleDoc_ItemCont_GetObjectA(
lpThis,
szItemName,
BINDSPEED_INDEFINITE,
lpbc,
&IID_IUnknown,
(LPVOID FAR*)&lpUnk
);
if (hrErr == NOERROR) {
OleStdRelease(lpUnk); // item name FOUND; don't need obj ptr.
CreateItemMonikerA(OLESTDDELIM, szItemName, lplpmkOut);
} else
*lpchEaten = 0; // item name is NOT valid
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_ParseDisplayName(
LPOLEITEMCONTAINER lpThis,
LPBC lpbc,
LPOLESTR lpszDisplayName,
ULONG FAR* lpchEaten,
LPMONIKER FAR* lplpmkOut
)
{
CREATESTR(lpsz, lpszDisplayName)
HRESULT hr = OleDoc_ItemCont_ParseDisplayNameA(lpThis, lpbc,
lpsz, lpchEaten, lplpmkOut);
FREESTR(lpsz);
return hr;
}
// IOleItemContainer::EnumObjects
STDMETHODIMP OleDoc_ItemCont_EnumObjects(
LPOLEITEMCONTAINER lpThis,
DWORD grfFlags,
LPENUMUNKNOWN FAR* lplpenumUnknown
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OLEDBG_BEGIN2("OleDoc_ItemCont_EnumObjects\r\n")
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpenumUnknown = NULL;
/* OLE2NOTE: this method should be implemented to allow programatic
** clients the ability to what elements the container holds.
** this method is NOT called in the standard linking scenarios.
**
** grfFlags can be one of the following:
** OLECONTF_EMBEDDINGS -- enumerate embedded objects
** OLECONTF_LINKS -- enumerate linked objects
** OLECONTF_OTHERS -- enumerate non-OLE compound doc objs
** OLECONTF_ONLYUSER -- enumerate only objs named by user
** OLECONTF_ONLYIFRUNNING-- enumerate only objs in running state
*/
OleDbgAssertSz(0, "NOT YET IMPLEMENTED!");
OLEDBG_END2
return ResultFromScode(E_NOTIMPL);
}
// IOleItemContainer::LockContainer
STDMETHODIMP OleDoc_ItemCont_LockContainer(
LPOLEITEMCONTAINER lpThis,
BOOL fLock
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_LockContainer\r\n")
#if defined( _DEBUG )
if (fLock) {
++lpOleDoc->m_cCntrLock;
OleDbgOutRefCnt3(
"OleDoc_ItemCont_LockContainer: cLock++\r\n",
lpOleDoc,
lpOleDoc->m_cCntrLock
);
} else {
/* OLE2NOTE: when there are no open documents and the app is not
** under the control of the user and there are no outstanding
** locks on the app, then revoke our ClassFactory to enable the
** app to shut down.
*/
--lpOleDoc->m_cCntrLock;
OleDbgAssertSz (
lpOleDoc->m_cCntrLock >= 0,
"OleDoc_ItemCont_LockContainer(FALSE) called with cLock == 0"
);
if (lpOleDoc->m_cCntrLock == 0) {
OleDbgOutRefCnt2(
"OleDoc_ItemCont_LockContainer: UNLOCKED\r\n",
lpOleDoc, lpOleDoc->m_cCntrLock);
} else {
OleDbgOutRefCnt3(
"OleDoc_ItemCont_LockContainer: cLock--\r\n",
lpOleDoc, lpOleDoc->m_cCntrLock);
}
}
#endif // _DEBUG
/* OLE2NOTE: in order to hold the document alive we call
** CoLockObjectExternal to add a strong reference to our Doc
** object. this will keep the Doc alive when all other external
** references release us. whenever an embedded object goes
** running a LockContainer(TRUE) is called. when the embedded
** object shuts down (ie. transitions from running to loaded)
** LockContainer(FALSE) is called. if the user issues File.Close
** the document will shut down in any case ignoring any
** outstanding LockContainer locks because CoDisconnectObject is
** called in OleDoc_Close. this will forceably break any
** existing strong reference counts including counts that we add
** ourselves by calling CoLockObjectExternal and guarantee that
** the Doc object gets its final release (ie. cRefs goes to 0).
*/
hrErr = OleDoc_Lock(lpOleDoc, fLock, TRUE /* fLastUnlockReleases */);
OLEDBG_END2
return hrErr;
}
// IOleItemContainer::GetObject
STDMETHODIMP OleDoc_ItemCont_GetObjectA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_GetObject\r\n")
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpvObject = NULL;
#if defined( OLE_SERVER )
/* OLE2NOTE: SERVER ONLY version should return PseudoObjects with
** BINDSPEED_IMMEDIATE, thus the dwSpeedNeeded is not important
** in the case of a pure server.
*/
hrErr = ServerDoc_GetObjectA(
(LPSERVERDOC)lpOleDoc, lpszItem,riid,lplpvObject);
#endif
#if defined( OLE_CNTR )
/* OLE2NOTE: dwSpeedNeeded indicates how long the caller is willing
** to wait for us to get the object:
** BINDSPEED_IMMEDIATE -- only if obj already loaded && IsRunning
** BINDSPEED_MODERATE -- load obj if necessary && if IsRunning
** BINDSPEED_INDEFINITE-- force obj to load and run if necessary
*/
hrErr = ContainerDoc_GetObjectA(
(LPCONTAINERDOC)lpOleDoc,lpszItem,dwSpeedNeeded,riid,lplpvObject);
#endif
OLEDBG_END2
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_GetObject(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_GetObjectA(lpThis, lpsz, dwSpeedNeeded, lpbc,
riid, lplpvObject);
FREESTR(lpsz)
return hr;
}
// IOleItemContainer::GetObjectStorage
STDMETHODIMP OleDoc_ItemCont_GetObjectStorageA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvStorage
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgOut2("OleDoc_ItemCont_GetObjectStorage\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpvStorage = NULL;
#if defined( OLE_SERVER )
/* OLE2NOTE: in the SERVER ONLY version, item names identify pseudo
** objects. pseudo objects, do NOT have identifiable storage.
*/
return ResultFromScode(E_FAIL);
#endif
#if defined( OLE_CNTR )
// We can only return an IStorage* type pointer
if (! IsEqualIID(riid, &IID_IStorage))
return ResultFromScode(E_FAIL);
return ContainerDoc_GetObjectStorageA(
(LPCONTAINERDOC)lpOleDoc,
lpszItem,
(LPSTORAGE FAR*)lplpvStorage
);
#endif
}
STDMETHODIMP OleDoc_ItemCont_GetObjectStorage(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvStorage
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_GetObjectStorageA(lpThis, lpsz, lpbc,
riid, lplpvStorage);
FREESTR(lpsz)
return hr;
}
// IOleItemContainer::IsRunning
STDMETHODIMP OleDoc_ItemCont_IsRunningA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_IsRunning\r\n")
/* OLE2NOTE: Check if item name is valid. if so then return if
** Object is running. PseudoObjects in the Server version are
** always considered running. Ole objects in the container must
** be checked if they are running.
*/
#if defined( OLE_SERVER )
hrErr = ServerDoc_IsRunningA((LPSERVERDOC)lpOleDoc, lpszItem);
#endif
#if defined( OLE_CNTR )
hrErr = ContainerDoc_IsRunningA((LPCONTAINERDOC)lpOleDoc, lpszItem);
#endif
OLEDBG_END2
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_IsRunning(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_IsRunningA(lpThis,lpsz);
FREESTR(lpsz)
return hr;
}
/*************************************************************************
** OleDoc::IExternalConnection interface implementation
*************************************************************************/
// IExternalConnection::QueryInterface
STDMETHODIMP OleDoc_ExtConn_QueryInterface(
LPEXTERNALCONNECTION lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IExternalConnection::AddRef
STDMETHODIMP_(ULONG) OleDoc_ExtConn_AddRef(LPEXTERNALCONNECTION lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IExternalConnection");
return OleDoc_AddRef(lpOleDoc);
}
// IExternalConnection::Release
STDMETHODIMP_(ULONG) OleDoc_ExtConn_Release (LPEXTERNALCONNECTION lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IExternalConnection");
return OleDoc_Release(lpOleDoc);
}
// IExternalConnection::AddConnection
STDMETHODIMP_(DWORD) OleDoc_ExtConn_AddConnection(
LPEXTERNALCONNECTION lpThis,
DWORD extconn,
DWORD reserved
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
if( extconn & EXTCONN_STRONG ) {
#if defined( _DEBUG )
OleDbgOutRefCnt3(
"OleDoc_ExtConn_AddConnection: dwStrongExtConn++\r\n",
lpOleDoc,
lpOleDoc->m_dwStrongExtConn + 1
);
#endif
return ++(lpOleDoc->m_dwStrongExtConn);
} else
return 0;
}
// IExternalConnection::ReleaseConnection
STDMETHODIMP_(DWORD) OleDoc_ExtConn_ReleaseConnection(
LPEXTERNALCONNECTION lpThis,
DWORD extconn,
DWORD reserved,
BOOL fLastReleaseCloses
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
if( extconn & EXTCONN_STRONG ){
DWORD dwSave = --(lpOleDoc->m_dwStrongExtConn);
#if defined( _DEBUG )
OLEDBG_BEGIN2( (fLastReleaseCloses ?
"OleDoc_ExtConn_ReleaseConnection(TRUE)\r\n" :
"OleDoc_ExtConn_ReleaseConnection(FALSE)\r\n") )
OleDbgOutRefCnt3(
"OleDoc_ExtConn_ReleaseConnection: dwStrongExtConn--\r\n",
lpOleDoc,
lpOleDoc->m_dwStrongExtConn
);
OleDbgAssertSz (
lpOleDoc->m_dwStrongExtConn >= 0,
"OleDoc_ExtConn_ReleaseConnection called with dwStrong == 0"
);
#endif // _DEBUG
if( lpOleDoc->m_dwStrongExtConn == 0 && fLastReleaseCloses )
OleDoc_Close(lpOleDoc, OLECLOSE_SAVEIFDIRTY);
OLEDBG_END2
return dwSave;
} else
return 0;
}
/*************************************************************************
** OleDoc Common Support Functions
*************************************************************************/
/* OleDoc_GetFullMoniker
** ---------------------
** Return the full, absolute moniker of the document.
**
** NOTE: the caller must release the pointer returned when done.
*/
LPMONIKER OleDoc_GetFullMoniker(LPOLEDOC lpOleDoc, DWORD dwAssign)
{
LPMONIKER lpMoniker = NULL;
OLEDBG_BEGIN3("OleDoc_GetFullMoniker\r\n")
if (lpOleDoc->m_lpSrcDocOfCopy) {
/* CASE I: this document was created for a copy or drag/drop
** operation. generate the moniker which identifies the
** source document of the original copy.
*/
if (! lpOleDoc->m_fLinkSourceAvail)
goto done; // we already know a moniker is not available
lpMoniker=OleDoc_GetFullMoniker(lpOleDoc->m_lpSrcDocOfCopy, dwAssign);
}
else if (lpOleDoc->m_lpFileMoniker) {
/* CASE II: this document is a top-level user document (either
** file-based or untitled). return the FileMoniker stored
** with the document; it uniquely identifies the document.
*/
// we must AddRef the moniker to pass out a ptr
lpOleDoc->m_lpFileMoniker->lpVtbl->AddRef(lpOleDoc->m_lpFileMoniker);
lpMoniker = lpOleDoc->m_lpFileMoniker;
}
#if defined( OLE_SERVER )
else if (((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite) {
/* CASE III: this document is an embedded object, ask our
** container for our moniker.
*/
OLEDBG_BEGIN2("IOleClientSite::GetMoniker called\r\n");
((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite->lpVtbl->GetMoniker(
((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite,
dwAssign,
OLEWHICHMK_OBJFULL,
&lpMoniker
);
OLEDBG_END2
}
#endif
else {
lpMoniker = NULL;
}
done:
OLEDBG_END3
return lpMoniker;
}
/* OleDoc_DocRenamedUpdate
** -----------------------
** Update the documents registration in the running object table (ROT).
** Also inform all embedded OLE objects (container only) and/or psedudo
** objects (server only) that the name of the document has changed.
*/
void OleDoc_DocRenamedUpdate(LPOLEDOC lpOleDoc, LPMONIKER lpmkDoc)
{
OLEDBG_BEGIN3("OleDoc_DocRenamedUpdate\r\n")
OleDoc_AddRef(lpOleDoc);
/* OLE2NOTE: we must re-register ourselves as running when we
** get a new moniker assigned (ie. when we are renamed).
*/
OLEDBG_BEGIN3("OleStdRegisterAsRunning called\r\n")
OleStdRegisterAsRunning(
(LPUNKNOWN)&lpOleDoc->m_Unknown,
lpmkDoc,
&lpOleDoc->m_dwRegROT
);
OLEDBG_END3
#if defined( OLE_SERVER )
{
LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
/* OLE2NOTE: inform any linking clients that the document has been
** renamed.
*/
ServerDoc_SendAdvise (
lpServerDoc,
OLE_ONRENAME,
lpmkDoc,
0 /* advf -- not relevant here */
);
/* OLE2NOTE: inform any clients of pseudo objects
** within our document, that our document's
** Moniker has changed.
*/
ServerNameTable_InformAllPseudoObjectsDocRenamed(
(LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable, lpmkDoc);
}
#endif
#if defined( OLE_CNTR )
{
LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc;
/* OLE2NOTE: must tell all OLE objects that our container
** moniker changed.
*/
ContainerDoc_InformAllOleObjectsDocRenamed(
lpContainerDoc,
lpmkDoc
);
}
#endif
OleDoc_Release(lpOleDoc); // release artificial AddRef above
OLEDBG_END3
}
#if defined( OLE_SERVER )
/*************************************************************************
** ServerDoc Supprt Functions Used by Server versions
*************************************************************************/
/* ServerDoc_PseudoObjLockDoc
** --------------------------
** Add a lock on the Doc on behalf of the PseudoObject. the Doc may not
** close while the Doc exists.
**
** when a pseudo object is first created, it calls this method to
** guarantee that the document stays alive (PseudoObj_Init).
** when a pseudo object is destroyed, it call
** ServerDoc_PseudoObjUnlockDoc to release this hold on the document.
*/
void ServerDoc_PseudoObjLockDoc(LPSERVERDOC lpServerDoc)
{
LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
ULONG cPseudoObj;
cPseudoObj = ++lpServerDoc->m_cPseudoObj;
#if defined( _DEBUG )
OleDbgOutRefCnt3(
"ServerDoc_PseudoObjLockDoc: cPseudoObj++\r\n",
lpServerDoc,
cPseudoObj
);
#endif
OleDoc_Lock(lpOleDoc, TRUE /* fLock */, 0 /* not applicable */);
return;
}
/* ServerDoc_PseudoObjUnlockDoc
** ----------------------------
** Release the lock on the Doc on behalf of the PseudoObject. if this was
** the last lock on the Doc, then it will shutdown.
*/
void ServerDoc_PseudoObjUnlockDoc(
LPSERVERDOC lpServerDoc,
LPPSEUDOOBJ lpPseudoObj
)
{
ULONG cPseudoObj;
LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
OLEDBG_BEGIN3("ServerDoc_PseudoObjUnlockDoc\r\n")
/* OLE2NOTE: when there are no active pseudo objects in the Doc and
** the Doc is not visible, and if there are no outstanding locks
** on the Doc, then this is a "silent update"
** situation. our Doc is being used programatically by some
** client; it is NOT accessible to the user because it is
** NOT visible. thus since all Locks have been released, we
** will close the document. if the app is only running due
** to the presence of this document, then the app will now
** also shut down.
*/
cPseudoObj = --lpServerDoc->m_cPseudoObj;
#if defined( _DEBUG )
OleDbgAssertSz (
lpServerDoc->m_cPseudoObj >= 0,
"PseudoObjUnlockDoc called with cPseudoObj == 0"
);
OleDbgOutRefCnt3(
"ServerDoc_PseudoObjUnlockDoc: cPseudoObj--\r\n",
lpServerDoc,
cPseudoObj
);
#endif
OleDoc_Lock(lpOleDoc, FALSE /* fLock */, TRUE /* fLastUnlockReleases */);
OLEDBG_END3
return;
}
/* ServerDoc_GetObject
** -------------------
**
** Return a pointer to an object identified by an item string
** (lpszItem). For a server-only app, the object returned will be a
** pseudo object.
*/
HRESULT ServerDoc_GetObjectA(
LPSERVERDOC lpServerDoc,
LPSTR lpszItem,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPPSEUDOOBJ lpPseudoObj;
LPSERVERNAMETABLE lpServerNameTable =
(LPSERVERNAMETABLE)((LPOUTLINEDOC)lpServerDoc)->m_lpNameTable;
*lplpvObject = NULL;
/* Get the PseudoObj which corresponds to an item name. if the item
** name does NOT exist in the name table then NO object is
** returned. the ServerNameTable_GetPseudoObj routine finds a
** name entry corresponding to the item name, it then checks if
** a PseudoObj has already been allocated. if so, it returns the
** existing object, otherwise it allocates a new PseudoObj.
*/
lpPseudoObj = ServerNameTable_GetPseudoObj(
lpServerNameTable,
lpszItem,
lpServerDoc
);
if (! lpPseudoObj) {
*lplpvObject = NULL;
return ResultFromScode(MK_E_NOOBJECT);
}
// return the desired interface pointer of the pseudo object.
return PseudoObj_QueryInterface(lpPseudoObj, riid, lplpvObject);
}
HRESULT ServerDoc_GetObject(
LPSERVERDOC lpServerDoc,
LPOLESTR lpszItem,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(pstr, lpszItem)
HRESULT hr = ServerDoc_GetObjectA(lpServerDoc, pstr, riid, lplpvObject);
FREESTR(pstr)
return hr;
}
/* ServerDoc_IsRunning
** -------------------
**
** Check if the object identified by an item string (lpszItem) is in
** the running state. For a server-only app, if the item name exists in
** in the NameTable then the item name is considered running.
** IOleItemContainer::GetObject would succeed.
*/
HRESULT ServerDoc_IsRunningA(LPSERVERDOC lpServerDoc, LPSTR lpszItem)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
((LPOUTLINEDOC)lpServerDoc)->m_lpNameTable;
LPSERVERNAME lpServerName;
lpServerName = (LPSERVERNAME)OutlineNameTable_FindName(
lpOutlineNameTable,
lpszItem
);
if (lpServerName)
return NOERROR;
else
return ResultFromScode(MK_E_NOOBJECT);
}
/* ServerDoc_GetSelRelMoniker
** --------------------------
** Retrieve the relative item moniker which identifies the given
** selection (lplrSel).
**
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ServerDoc_GetSelRelMoniker(
LPSERVERDOC lpServerDoc,
LPLINERANGE lplrSel,
DWORD dwAssign
)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
LPSERVERNAMETABLE lpServerNameTable =
(LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable;
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPMONIKER lpmk;
lpOutlineName=OutlineNameTable_FindNamedRange(lpOutlineNameTable,lplrSel);
if (lpOutlineName) {
/* the selection range already has a name assigned */
CreateItemMonikerA(OLESTDDELIM, lpOutlineName->m_szName, &lpmk);
} else {
char szbuf[MAXNAMESIZE];
switch (dwAssign) {
case GETMONIKER_FORCEASSIGN:
/* Force the assignment of the name. This is called when a
** Paste Link actually occurs. At this point we want to
** create a Name and add it to the NameTable in order to
** track the source of the link. This name (as all
** names) will be updated upon editing of the document.
*/
wsprintf(
szbuf,
"%s %ld",
(LPSTR)DEFRANGENAMEPREFIX,
++(lpServerDoc->m_nNextRangeNo)
);
lpOutlineName = OutlineApp_CreateName(lpOutlineApp);
if (lpOutlineName) {
lstrcpy(lpOutlineName->m_szName, szbuf);
lpOutlineName->m_nStartLine = lplrSel->m_nStartLine;
lpOutlineName->m_nEndLine = lplrSel->m_nEndLine;
OutlineDoc_AddName(lpOutlineDoc, lpOutlineName);
} else {
// REVIEW: do we need "Out-of-Memory" error message here?
}
break;
case GETMONIKER_TEMPFORUSER:
/* Create a name to show to the user in the Paste
** Special dialog but do NOT yet incur the overhead
** of adding a Name to the NameTable. The Moniker
** generated should be useful to display to the user
** to indicate the source of the copy, but will NOT
** be used to create a link directly (the caller
** should ask again for a moniker specifying FORCEASSIGN).
** we will generate the name that would be the next
** auto-generated range name, BUT will NOT actually
** increment the range counter.
*/
wsprintf(
szbuf,
"%s %ld",
(LPSTR)DEFRANGENAMEPREFIX,
(lpServerDoc->m_nNextRangeNo)+1
);
break;
case GETMONIKER_ONLYIFTHERE:
/* the caller only wants a name if one has already been
** assigned. we have already above checked if the
** current selection has a name, so we will simply
** return NULL here.
*/
return NULL; // no moniker is assigned
default:
return NULL; // unknown flag given
}
CreateItemMonikerA(OLESTDDELIM, szbuf, &lpmk);
}
return lpmk;
}
/* ServerDoc_GetSelFullMoniker
** ---------------------------
** Retrieve the full absolute moniker which identifies the given
** selection (lplrSel).
** this moniker is created as a composite of the absolute moniker for
** the entire document appended with an item moniker which identifies
** the selection relative to the document.
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ServerDoc_GetSelFullMoniker(
LPSERVERDOC lpServerDoc,
LPLINERANGE lplrSel,
DWORD dwAssign
)
{
LPMONIKER lpmkDoc = NULL;
LPMONIKER lpmkItem = NULL;
LPMONIKER lpmkFull = NULL;
lpmkDoc = OleDoc_GetFullMoniker(
(LPOLEDOC)lpServerDoc,
dwAssign
);
if (! lpmkDoc) return NULL;
lpmkItem = ServerDoc_GetSelRelMoniker(
lpServerDoc,
lplrSel,
dwAssign
);
if (lpmkItem) {
CreateGenericComposite(lpmkDoc, lpmkItem, (LPMONIKER FAR*)&lpmkFull);
OleStdRelease((LPUNKNOWN)lpmkItem);
}
if (lpmkDoc)
OleStdRelease((LPUNKNOWN)lpmkDoc);
return lpmkFull;
}
/* ServerNameTable_EditLineUpdate
* -------------------------------
*
* Update the table when a line at nEditIndex is edited.
*/
void ServerNameTable_EditLineUpdate(
LPSERVERNAMETABLE lpServerNameTable,
int nEditIndex
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LINERANGE lrSel;
LPPSEUDOOBJ lpPseudoObj;
int i;
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** check if the line that was modified is included within
** the named range.
*/
if (lpPseudoObj) {
OutlineName_GetSel(lpOutlineName, &lrSel);
if(((int)lrSel.m_nStartLine <= nEditIndex) &&
((int)lrSel.m_nEndLine >= nEditIndex)) {
// inform linking clients data has changed
PseudoObj_SendAdvise(
lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
}
}
}
/* ServerNameTable_InformAllPseudoObjectsDocRenamed
* ------------------------------------------------
*
* Inform all pseudo object clients that the name of the pseudo
* object has changed.
*/
void ServerNameTable_InformAllPseudoObjectsDocRenamed(
LPSERVERNAMETABLE lpServerNameTable,
LPMONIKER lpmkDoc
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPPSEUDOOBJ lpPseudoObj;
LPMONIKER lpmkObj;
int i;
OLEDBG_BEGIN2("ServerNameTable_InformAllPseudoObjectsDocRenamed\r\n");
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** send OnRename advise to its linking clients.
*/
if (lpPseudoObj &&
((lpmkObj=PseudoObj_GetFullMoniker(lpPseudoObj,lpmkDoc))!=NULL)) {
// inform the clients that the name has changed
PseudoObj_SendAdvise (
lpPseudoObj,
OLE_ONRENAME,
lpmkObj,
0 /* advf -- not relevant here */
);
}
}
OLEDBG_END2
}
/* ServerNameTable_InformAllPseudoObjectsDocSaved
* ------------------------------------------------
*
* Inform all pseudo object clients that the name of the pseudo
* object has changed.
*/
void ServerNameTable_InformAllPseudoObjectsDocSaved(
LPSERVERNAMETABLE lpServerNameTable,
LPMONIKER lpmkDoc
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPPSEUDOOBJ lpPseudoObj;
LPMONIKER lpmkObj;
int i;
OLEDBG_BEGIN2("ServerNameTable_InformAllPseudoObjectsDocSaved\r\n");
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** send OnSave advise to its linking clients.
*/
if (lpPseudoObj &&
((lpmkObj=PseudoObj_GetFullMoniker(lpPseudoObj,lpmkDoc))!=NULL)) {
// inform the clients that the name has been saved
PseudoObj_SendAdvise (
lpPseudoObj,
OLE_ONSAVE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- not relevant here */
);
}
}
OLEDBG_END2
}
/* ServerNameTable_SendPendingAdvises
* ----------------------------------
*
* Send any pending change notifications for pseudo objects.
* while ReDraw is diabled on the ServerDoc, then change advise
* notifications are not sent to pseudo object clients.
*/
void ServerNameTable_SendPendingAdvises(LPSERVERNAMETABLE lpServerNameTable)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPSERVERNAME lpServerName;
int i;
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpServerName = (LPSERVERNAME)OutlineNameTable_GetName(
lpOutlineNameTable,
i
);
ServerName_SendPendingAdvises(lpServerName);
}
}
/* ServerNameTable_GetPseudoObj
** ----------------------------
**
** Return a pointer to a pseudo object identified by an item string
** (lpszItem). if the pseudo object already exists, then return the
** existing object, otherwise allocate a new pseudo object.
*/
LPPSEUDOOBJ ServerNameTable_GetPseudoObj(
LPSERVERNAMETABLE lpServerNameTable,
LPSTR lpszItem,
LPSERVERDOC lpServerDoc
)
{
LPSERVERNAME lpServerName;
lpServerName = (LPSERVERNAME)OutlineNameTable_FindName(
(LPOUTLINENAMETABLE)lpServerNameTable,
lpszItem
);
if (lpServerName)
return ServerName_GetPseudoObj(lpServerName, lpServerDoc);
else
return NULL;
}
/* ServerNameTable_CloseAllPseudoObjs
* ----------------------------------
*
* Force all pseudo objects to close. this results in sending OnClose
* notification to each pseudo object's linking clients.
*/
void ServerNameTable_CloseAllPseudoObjs(LPSERVERNAMETABLE lpServerNameTable)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPSERVERNAME lpServerName;
int i;
OLEDBG_BEGIN3("ServerNameTable_CloseAllPseudoObjs\r\n")
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpServerName = (LPSERVERNAME)OutlineNameTable_GetName(
lpOutlineNameTable,
i
);
ServerName_ClosePseudoObj(lpServerName);
}
OLEDBG_END3
}
/* ServerName_SetSel
* -----------------
*
* Change the line range of a name.
*/
void ServerName_SetSel(
LPSERVERNAME lpServerName,
LPLINERANGE lplrSel,
BOOL fRangeModified
)
{
LPOUTLINENAME lpOutlineName = (LPOUTLINENAME)lpServerName;
BOOL fPseudoObjChanged = fRangeModified;
if (lpOutlineName->m_nStartLine != lplrSel->m_nStartLine) {
lpOutlineName->m_nStartLine = lplrSel->m_nStartLine;
fPseudoObjChanged = TRUE;
}
if (lpOutlineName->m_nEndLine != lplrSel->m_nEndLine) {
lpOutlineName->m_nEndLine = lplrSel->m_nEndLine;
fPseudoObjChanged = TRUE;
}
/* OLE2NOTE: if the range of an active pseudo object has
** changed, then inform any linking clients that the object
** has changed.
*/
if (lpServerName->m_lpPseudoObj && fPseudoObjChanged) {
PseudoObj_SendAdvise(
lpServerName->m_lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
}
/* ServerName_SendPendingAdvises
* -----------------------------
*
* Send any pending change notifications for the associated
* pseudo objects for this name (if one exists).
* while ReDraw is diabled on the ServerDoc, then change advise
* notifications are not sent to pseudo object clients.
*/
void ServerName_SendPendingAdvises(LPSERVERNAME lpServerName)
{
if (! lpServerName->m_lpPseudoObj)
return; // no associated pseudo object
if (lpServerName->m_lpPseudoObj->m_fDataChanged)
PseudoObj_SendAdvise(
lpServerName->m_lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
/* ServerName_GetPseudoObj
** -----------------------
**
** Return a pointer to a pseudo object associated to a ServerName.
** if the pseudo object already exists, then return the
** existing object, otherwise allocate a new pseudo object.
**
** NOTE: the PseudoObj is returned with a 0 refcnt if first created,
** else the existing refcnt is unchanged.
*/
LPPSEUDOOBJ ServerName_GetPseudoObj(
LPSERVERNAME lpServerName,
LPSERVERDOC lpServerDoc
)
{
// Check if a PseudoObj already exists
if (lpServerName->m_lpPseudoObj)
return lpServerName->m_lpPseudoObj;
// A PseudoObj does NOT already exist, allocate a new one.
lpServerName->m_lpPseudoObj=(LPPSEUDOOBJ) New((DWORD)sizeof(PSEUDOOBJ));
if (lpServerName->m_lpPseudoObj == NULL) {
OleDbgAssertSz(lpServerName->m_lpPseudoObj != NULL, "Error allocating PseudoObj");
return NULL;
}
PseudoObj_Init(lpServerName->m_lpPseudoObj, lpServerName, lpServerDoc);
return lpServerName->m_lpPseudoObj;
}
/* ServerName_ClosePseudoObj
* -------------------------
*
* if there is an associated pseudo objects for this name (if one
* exists), then close it. this results in sending OnClose
* notification to the pseudo object's linking clients.
*/
void ServerName_ClosePseudoObj(LPSERVERNAME lpServerName)
{
if (!lpServerName || !lpServerName->m_lpPseudoObj)
return; // no associated pseudo object
PseudoObj_Close(lpServerName->m_lpPseudoObj);
}
#endif // OLE_SERVER
#if defined( OLE_CNTR )
/*************************************************************************
** ContainerDoc Supprt Functions Used by Container versions
*************************************************************************/
/* ContainerLine_GetRelMoniker
** ---------------------------
** Retrieve the relative item moniker which identifies the OLE object
** relative to the container document.
**
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ContainerLine_GetRelMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
)
{
LPMONIKER lpmk = NULL;
/* OLE2NOTE: we should only give out a moniker for the OLE object
** if the object is allowed to be linked to from the inside. if
** so we are allowed to give out a moniker which binds to the
** running OLE object). if the object is an OLE 2.0 embedded
** object then it is allowed to be linked to from the inside. if
** the object is either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we could offer linking
** to the outside of the object (ie. a pseudo object within our
** document). we are a container only app that does not support
** linking to ranges of its data.
*/
switch (dwAssign) {
case GETMONIKER_FORCEASSIGN:
/* Force the assignment of the name. This is called when a
** Paste Link actually occurs. From now on we want
** to inform the OLE object that its moniker is
** assigned and is thus necessary to register itself
** in the RunningObjectTable.
*/
CreateItemMonikerA(
OLESTDDELIM, lpContainerLine->m_szStgName, &lpmk);
/* OLE2NOTE: if the OLE object is already loaded and it
** is being assigned a moniker for the first time,
** then we need to inform it that it now has a moniker
** assigned by calling IOleObject::SetMoniker. this
** will force the OLE object to register in the
** RunningObjectTable when it enters the running
** state. if the object is not currently loaded,
** SetMoniker will be called automatically later when
** the object is loaded by the function
** ContainerLine_LoadOleObject.
*/
if (! lpContainerLine->m_fMonikerAssigned) {
/* we must remember forever more that this object has a
** moniker assigned.
*/
lpContainerLine->m_fMonikerAssigned = TRUE;
// we are now dirty and must be saved
OutlineDoc_SetModified(
(LPOUTLINEDOC)lpContainerLine->m_lpDoc,
TRUE, /* fModified */
FALSE, /* fDataChanged--N/A for container ver. */
FALSE /* fSizeChanged--N/A for container ver. */
);
if (lpContainerLine->m_lpOleObj) {
OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
lpContainerLine->m_lpOleObj,
OLEWHICHMK_OBJREL,
lpmk
);
OLEDBG_END2
}
}
break;
case GETMONIKER_ONLYIFTHERE:
/* If the OLE object currently has a moniker assigned,
** then return it.
*/
if (lpContainerLine->m_fMonikerAssigned) {
CreateItemMonikerA(
OLESTDDELIM,
lpContainerLine->m_szStgName,
&lpmk
);
}
break;
case GETMONIKER_TEMPFORUSER:
/* Return the moniker that would be used for the OLE
** object but do NOT force moniker assignment at
** this point. Since our strategy is to use the
** storage name of the object as its item name, we
** can simply create the corresponding ItemMoniker
** (indepenedent of whether the moniker is currently
** assigned or not).
*/
CreateItemMonikerA(
OLESTDDELIM,
lpContainerLine->m_szStgName,
&lpmk
);
break;
case GETMONIKER_UNASSIGN:
lpContainerLine->m_fMonikerAssigned = FALSE;
break;
}
return lpmk;
}
/* ContainerLine_GetFullMoniker
** ----------------------------
** Retrieve the full absolute moniker which identifies the OLE object
** in the container document.
** this moniker is created as a composite of the absolute moniker for
** the entire document appended with an item moniker which identifies
** the OLE object relative to the document.
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ContainerLine_GetFullMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
)
{
LPMONIKER lpmkDoc = NULL;
LPMONIKER lpmkItem = NULL;
LPMONIKER lpmkFull = NULL;
lpmkDoc = OleDoc_GetFullMoniker(
(LPOLEDOC)lpContainerLine->m_lpDoc,
dwAssign
);
if (! lpmkDoc) return NULL;
lpmkItem = ContainerLine_GetRelMoniker(lpContainerLine, dwAssign);
if (lpmkItem) {
CreateGenericComposite(lpmkDoc, lpmkItem, (LPMONIKER FAR*)&lpmkFull);
OleStdRelease((LPUNKNOWN)lpmkItem);
}
if (lpmkDoc)
OleStdRelease((LPUNKNOWN)lpmkDoc);
return lpmkFull;
}
/* ContainerDoc_InformAllOleObjectsDocRenamed
** ------------------------------------------
** Inform all OLE objects that the name of the ContainerDoc has changed.
*/
void ContainerDoc_InformAllOleObjectsDocRenamed(
LPCONTAINERDOC lpContainerDoc,
LPMONIKER lpmkDoc
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
/* OLE2NOTE: if the OLE object is already loaded AND the
** object already has a moniker assigned, then we need
** to inform it that the moniker of the ContainerDoc has
** changed. of course, this means the full moniker of
** the object has changed. to do this we call
** IOleObject::SetMoniker. this will force the OLE
** object to re-register in the RunningObjectTable if it
** is currently in the running state. it is not in the
** running state, the object handler can make not that
** the object has a new moniker. if the object is not
** currently loaded, SetMoniker will be called
** automatically later when the object is loaded by the
** function ContainerLine_LoadOleObject.
** also if the object is a linked object, we always want
** to call SetMoniker on the link so that in case the
** link source is contained within our same container,
** the link source will be tracked. the link rebuilds
** its absolute moniker if it has a relative moniker.
*/
if (lpContainerLine->m_lpOleObj) {
if (lpContainerLine->m_fMonikerAssigned ||
lpContainerLine->m_dwLinkType != 0) {
OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
lpContainerLine->m_lpOleObj,
OLEWHICHMK_CONTAINER,
lpmkDoc
);
OLEDBG_END2
}
/* OLE2NOTE: we must call IOleObject::SetHostNames so
** any open objects can update their window titles.
*/
OLEDBG_BEGIN2("IOleObject::SetHostNames called\r\n")
CallIOleObjectSetHostNamesA(
lpContainerLine->m_lpOleObj,
APPNAME,
((LPOUTLINEDOC)lpContainerDoc)->m_lpszDocTitle
);
OLEDBG_END2
}
}
}
}
/* ContainerDoc_GetObject
** ----------------------
** Return a pointer to the desired interface of an object identified
** by an item string (lpszItem). the object returned will be an OLE
** object (either link or embedding).
**
** OLE2NOTE: we must force the object to run because we are
** REQUIRED to return a pointer the OLE object in the
** RUNNING state.
**
** dwSpeedNeeded indicates how long the caller is willing
** to wait for us to get the object:
** BINDSPEED_IMMEDIATE -- only if obj already loaded && IsRunning
** BINDSPEED_MODERATE -- load obj if necessary && if IsRunning
** BINDSPEED_INDEFINITE-- force obj to load and run if necessary
*/
HRESULT ContainerDoc_GetObjectA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
BOOL fMatchFound = FALSE;
DWORD dwStatus;
HRESULT hrErr;
*lplpvObject = NULL;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
fMatchFound = TRUE; // valid item name
// check if object is loaded.
if (lpContainerLine->m_lpOleObj == NULL) {
// if BINDSPEED_IMMEDIATE is requested, object must
// ALREADY be loadded.
if (dwSpeedNeeded == BINDSPEED_IMMEDIATE)
return ResultFromScode(MK_E_EXCEEDEDDEADLINE);
ContainerLine_LoadOleObject(lpContainerLine);
if (! lpContainerLine->m_lpOleObj)
return ResultFromScode(E_OUTOFMEMORY);
}
/* OLE2NOTE: check if the object is allowed to be linked
** to from the inside (ie. we are allowed to
** give out a moniker which binds to the running
** OLE object). if the object is an OLE
** 2.0 embedded object then it is allowed to be
** linked to from the inside. if the object is
** either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we
** could offer linking to the outside of the
** object (ie. a pseudo object within our
** document). we are a container only app that
** does not support linking to ranges of its data.
*/
OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n");
lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
lpContainerLine->m_lpOleObj,
DVASPECT_CONTENT, /* aspect is not important */
(LPDWORD)&dwStatus
);
OLEDBG_END2
if (dwStatus & OLEMISC_CANTLINKINSIDE)
return ResultFromScode(MK_E_NOOBJECT);
// check if object is running.
if (! OleIsRunning(lpContainerLine->m_lpOleObj)) {
// if BINDSPEED_MODERATE is requested, object must
// ALREADY be running.
if (dwSpeedNeeded == BINDSPEED_MODERATE)
return ResultFromScode(MK_E_EXCEEDEDDEADLINE);
/* OLE2NOTE: we have found a match for the item name.
** now we must return a pointer to the desired
** interface on the RUNNING object. we must
** carefully load the object and initially ask for
** an interface that we are sure the loaded form of
** the object supports. if we immediately ask the
** loaded object for the desired interface, the
** QueryInterface call might fail if it is an
** interface that is supported only when the object
** is running. thus we force the object to load and
** return its IUnknown*. then we force the object to
** run, and then finally, we can ask for the
** actually requested interface.
*/
hrErr = ContainerLine_RunOleObject(lpContainerLine);
if (hrErr != NOERROR) {
return hrErr;
}
}
// Retrieve the requested interface
*lplpvObject = OleStdQueryInterface(
(LPUNKNOWN)lpContainerLine->m_lpOleObj, riid);
break; // Match FOUND!
}
}
}
if (*lplpvObject != NULL) {
return NOERROR;
} else
return (fMatchFound ? ResultFromScode(E_NOINTERFACE)
: ResultFromScode(MK_E_NOOBJECT));
}
HRESULT ContainerDoc_GetObject(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_GetObjectA(lpContainerDoc, lpsz, dwSpeedNeeded,
riid, lplpvObject);
FREESTR(lpsz)
return hr;
}
/* ContainerDoc_GetObjectStorage
** -----------------------------
** Return a pointer to the IStorage* used by the object identified
** by an item string (lpszItem). the object identified could be either
** an OLE object (either link or embedding).
*/
HRESULT ContainerDoc_GetObjectStorageA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
LPSTORAGE FAR* lplpStg
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
*lplpStg = NULL;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
*lplpStg = lpContainerLine->m_lpStg;
break; // Match FOUND!
}
}
}
if (*lplpStg != NULL) {
return NOERROR;
} else
return ResultFromScode(MK_E_NOOBJECT);
}
HRESULT ContainerDoc_GetObjectStorage(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
LPSTORAGE FAR* lplpStg
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_GetObjectStorageA(lpContainerDoc, lpsz, lplpStg);
FREESTR(lpsz)
return hr;
}
/* ContainerDoc_IsRunning
** ----------------------
** Check if the object identified by an item string (lpszItem) is in
** the running state.
** For a container-only app, a check is made if the OLE object
** associated with the item name is running.
*/
HRESULT ContainerDoc_IsRunningA(LPCONTAINERDOC lpContainerDoc, LPSTR lpszItem)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
DWORD dwStatus;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
/* OLE2NOTE: we have found a match for the item name.
** now we must check if the OLE object is running.
** we will load the object if not already loaded.
*/
if (! lpContainerLine->m_lpOleObj) {
ContainerLine_LoadOleObject(lpContainerLine);
if (! lpContainerLine->m_lpOleObj)
return ResultFromScode(E_OUTOFMEMORY);
}
/* OLE2NOTE: check if the object is allowed to be linked
** to from the inside (ie. we are allowed to
** give out a moniker which binds to the running
** OLE object). if the object is an OLE
** 2.0 embedded object then it is allowed to be
** linked to from the inside. if the object is
** either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we
** could offer linking to the outside of the
** object (ie. a pseudo object within our
** document). we are a container only app that
** does not support linking to ranges of its data.
*/
OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
lpContainerLine->m_lpOleObj,
DVASPECT_CONTENT, /* aspect is not important */
(LPDWORD)&dwStatus
);
OLEDBG_END2
if (dwStatus & OLEMISC_CANTLINKINSIDE)
return ResultFromScode(MK_E_NOOBJECT);
if (OleIsRunning(lpContainerLine->m_lpOleObj))
return NOERROR;
else
return ResultFromScode(S_FALSE);
}
}
}
// no object was found corresponding to the item name
return ResultFromScode(MK_E_NOOBJECT);
}
HRESULT ContainerDoc_IsRunning(LPCONTAINERDOC lpContainerDoc, LPOLESTR lpszItem)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_IsRunningA(lpContainerDoc, lpsz);
FREESTR(lpsz)
return hr;
}
#endif // OLE_CNTR
|
792427.c | /*
* Copyright (c) 2001, Adam Dunkels.
* Copyright (c) 2009, 2010 Joakim Eriksson, Niclas Finne, Dogan Yazar.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the uIP TCP/IP stack.
*
*
*/
/* Below define allows importing saved output into Wireshark as "Raw IP" packet type */
#define WIRESHARK_IMPORT_FORMAT 1
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <err.h>
#include "tools-utils.h"
#ifndef BAUDRATE
#define BAUDRATE B115200
#endif
speed_t b_rate = BAUDRATE;
int verbose = 2;
const char *ipaddr;
const char *netmask;
int slipfd = 0;
uint16_t basedelay=0,delaymsec=0;
uint32_t startsec,startmsec,delaystartsec,delaystartmsec;
int timestamp = 0, flowcontrol=0, showprogress=0, flowcontrol_xonxoff=0;
int ssystem(const char *fmt, ...)
__attribute__((__format__ (__printf__, 1, 2)));
void write_to_serial(int outfd, void *inbuf, int len);
void slip_send(int fd, unsigned char c);
void slip_send_char(int fd, unsigned char c);
#define PROGRESS(s) if(showprogress) fprintf(stderr, s)
char tundev[1024] = { "" };
/* IPv6 required minimum MTU */
#define MIN_DEVMTU 1500
int devmtu = MIN_DEVMTU;
int
ssystem(const char *fmt, ...) __attribute__((__format__ (__printf__, 1, 2)));
int
ssystem(const char *fmt, ...)
{
char cmd[128];
va_list ap;
va_start(ap, fmt);
vsnprintf(cmd, sizeof(cmd), fmt, ap);
va_end(ap);
printf("%s\n", cmd);
fflush(stdout);
return system(cmd);
}
#define SLIP_END 0300
#define SLIP_ESC 0333
#define SLIP_ESC_END 0334
#define SLIP_ESC_ESC 0335
#define SLIP_ESC_XON 0336
#define SLIP_ESC_XOFF 0337
#define XON 17
#define XOFF 19
/* get sockaddr, IPv4 or IPv6: */
void *
get_in_addr(struct sockaddr *sa)
{
if(sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr);
}
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
void
stamptime(void)
{
static long startsecs=0,startmsecs=0;
long secs,msecs;
struct timeval tv;
time_t t;
struct tm *tmp;
char timec[20];
gettimeofday(&tv, NULL) ;
msecs=tv.tv_usec/1000;
secs=tv.tv_sec;
if (startsecs) {
secs -=startsecs;
msecs-=startmsecs;
if (msecs<0) {secs--;msecs+=1000;}
fprintf(stderr,"%04lu.%03lu ", secs, msecs);
} else {
startsecs=secs;
startmsecs=msecs;
t=time(NULL);
tmp=localtime(&t);
strftime(timec,sizeof(timec),"%T",tmp);
// fprintf(stderr,"\n%s.%03lu ",timec,msecs);
fprintf(stderr,"\n%s ",timec);
}
}
int
is_sensible_string(const unsigned char *s, int len)
{
int i;
for(i = 1; i < len; i++) {
if(s[i] == 0 || s[i] == '\r' || s[i] == '\n' || s[i] == '\t') {
continue;
} else if(s[i] < ' ' || '~' < s[i]) {
return 0;
}
}
return 1;
}
/*
* Read from serial, when we have a packet write it to tun. No output
* buffering, input buffered by stdio.
*/
void
serial_to_tun(FILE *inslip, int outfd)
{
static union {
unsigned char inbuf[2000];
} uip;
static int inbufptr = 0;
int ret,i;
unsigned char c;
#ifdef linux
ret = fread(&c, 1, 1, inslip);
if(ret == -1 || ret == 0) err(1, "serial_to_tun: read");
goto after_fread;
#endif
read_more:
if(inbufptr >= sizeof(uip.inbuf)) {
if(timestamp) stamptime();
fprintf(stderr, "*** dropping large %d byte packet\n",inbufptr);
inbufptr = 0;
}
ret = fread(&c, 1, 1, inslip);
#ifdef linux
after_fread:
#endif
if(ret == -1) {
err(1, "serial_to_tun: read");
}
if(ret == 0) {
clearerr(inslip);
return;
}
PROGRESS(".");
switch(c) {
case SLIP_END:
if(inbufptr > 0) {
if(uip.inbuf[0] == '!') {
if(uip.inbuf[1] == 'M') {
/* Read gateway MAC address and autoconfigure tap0 interface */
char macs[24];
int i, pos;
for(i = 0, pos = 0; i < 16; i++) {
macs[pos++] = uip.inbuf[2 + i];
if((i & 1) == 1 && i < 14) {
macs[pos++] = ':';
}
}
if(timestamp) stamptime();
macs[pos] = '\0';
// printf("*** Gateway's MAC address: %s\n", macs);
fprintf(stderr,"*** Gateway's MAC address: %s\n", macs);
if (timestamp) stamptime();
ssystem("ifconfig %s down", tundev);
if (timestamp) stamptime();
ssystem("ifconfig %s hw ether %s", tundev, &macs[6]);
if (timestamp) stamptime();
ssystem("ifconfig %s up", tundev);
}
} else if(uip.inbuf[0] == '?') {
if(uip.inbuf[1] == 'P') {
/* Prefix info requested */
struct in6_addr addr;
int i;
char *s = strchr(ipaddr, '/');
if(s != NULL) {
*s = '\0';
}
inet_pton(AF_INET6, ipaddr, &addr);
if(timestamp) stamptime();
fprintf(stderr,"*** Address:%s => %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
ipaddr,
addr.s6_addr[0], addr.s6_addr[1],
addr.s6_addr[2], addr.s6_addr[3],
addr.s6_addr[4], addr.s6_addr[5],
addr.s6_addr[6], addr.s6_addr[7]);
slip_send(slipfd, '!');
slip_send(slipfd, 'P');
for(i = 0; i < 8; i++) {
/* need to call the slip_send_char for stuffing */
slip_send_char(slipfd, addr.s6_addr[i]);
}
slip_send(slipfd, SLIP_END);
}
#define DEBUG_LINE_MARKER '\r'
} else if(uip.inbuf[0] == DEBUG_LINE_MARKER) {
fwrite(uip.inbuf + 1, inbufptr - 1, 1, stdout);
} else if(is_sensible_string(uip.inbuf, inbufptr)) {
if(verbose==1) { /* strings already echoed below for verbose>1 */
if (timestamp) stamptime();
fwrite(uip.inbuf, inbufptr, 1, stdout);
}
} else {
if(verbose>2) {
if (timestamp) stamptime();
printf("Packet from SLIP of length %d - write TUN\n", inbufptr);
if (verbose>4) {
#if WIRESHARK_IMPORT_FORMAT
printf("0000");
for(i = 0; i < inbufptr; i++) printf(" %02x",uip.inbuf[i]);
#else
printf(" ");
for(i = 0; i < inbufptr; i++) {
printf("%02x", uip.inbuf[i]);
if((i & 3) == 3) printf(" ");
if((i & 15) == 15) printf("\n ");
}
#endif
printf("\n");
}
}
if(write(outfd, uip.inbuf, inbufptr) != inbufptr) {
err(1, "serial_to_tun: write");
}
}
inbufptr = 0;
}
break;
case SLIP_ESC:
if(fread(&c, 1, 1, inslip) != 1) {
clearerr(inslip);
/* Put ESC back and give up! */
ungetc(SLIP_ESC, inslip);
return;
}
switch(c) {
case SLIP_ESC_END:
c = SLIP_END;
break;
case SLIP_ESC_ESC:
c = SLIP_ESC;
break;
case SLIP_ESC_XON:
c = XON;
break;
case SLIP_ESC_XOFF:
c = XOFF;
break;
}
/* FALLTHROUGH */
default:
uip.inbuf[inbufptr++] = c;
/* Echo lines as they are received for verbose=2,3,5+ */
/* Echo all printable characters for verbose==4 */
if((verbose==2) || (verbose==3) || (verbose>4)) {
if(c=='\n') {
if(is_sensible_string(uip.inbuf, inbufptr)) {
if (timestamp) stamptime();
fwrite(uip.inbuf, inbufptr, 1, stdout);
inbufptr=0;
}
}
} else if(verbose==4) {
if(c == 0 || c == '\r' || c == '\n' || c == '\t' || (c >= ' ' && c <= '~')) {
fwrite(&c, 1, 1, stdout);
if(c=='\n') if(timestamp) stamptime();
}
}
break;
}
goto read_more;
}
unsigned char slip_buf[2000];
int slip_end, slip_begin;
void
slip_send_char(int fd, unsigned char c)
{
switch(c) {
case SLIP_END:
slip_send(fd, SLIP_ESC);
slip_send(fd, SLIP_ESC_END);
break;
case SLIP_ESC:
slip_send(fd, SLIP_ESC);
slip_send(fd, SLIP_ESC_ESC);
break;
case XON:
if(flowcontrol_xonxoff) {
slip_send(fd, SLIP_ESC);
slip_send(fd, SLIP_ESC_XON);
} else {
slip_send(fd, c);
}
break;
case XOFF:
if(flowcontrol_xonxoff) {
slip_send(fd, SLIP_ESC);
slip_send(fd, SLIP_ESC_XOFF);
} else {
slip_send(fd, c);
}
break;
default:
slip_send(fd, c);
break;
}
}
void
slip_send(int fd, unsigned char c)
{
if(slip_end >= sizeof(slip_buf)) {
err(1, "slip_send overflow");
}
slip_buf[slip_end] = c;
slip_end++;
}
int
slip_empty()
{
return slip_end == 0;
}
void
slip_flushbuf(int fd)
{
int n;
if(slip_empty()) {
return;
}
n = write(fd, slip_buf + slip_begin, (slip_end - slip_begin));
if(n == -1 && errno != EAGAIN) {
err(1, "slip_flushbuf write failed");
} else if(n == -1) {
PROGRESS("Q"); /* Outqueueis full! */
} else {
slip_begin += n;
if(slip_begin == slip_end) {
slip_begin = slip_end = 0;
}
}
}
void
write_to_serial(int outfd, void *inbuf, int len)
{
u_int8_t *p = inbuf;
int i;
if(verbose>2) {
if (timestamp) stamptime();
printf("Packet from TUN of length %d - write SLIP\n", len);
if (verbose>4) {
#if WIRESHARK_IMPORT_FORMAT
printf("0000");
for(i = 0; i < len; i++) printf(" %02x", p[i]);
#else
printf(" ");
for(i = 0; i < len; i++) {
printf("%02x", p[i]);
if((i & 3) == 3) printf(" ");
if((i & 15) == 15) printf("\n ");
}
#endif
printf("\n");
}
}
/* It would be ``nice'' to send a SLIP_END here but it's not
* really necessary.
*/
/* slip_send(outfd, SLIP_END); */
for(i = 0; i < len; i++) {
switch(p[i]) {
case SLIP_END:
slip_send(outfd, SLIP_ESC);
slip_send(outfd, SLIP_ESC_END);
break;
case SLIP_ESC:
slip_send(outfd, SLIP_ESC);
slip_send(outfd, SLIP_ESC_ESC);
break;
case XON:
if(flowcontrol_xonxoff) {
slip_send(outfd, SLIP_ESC);
slip_send(outfd, SLIP_ESC_XON);
} else {
slip_send(outfd, p[i]);
}
break;
case XOFF:
if(flowcontrol_xonxoff) {
slip_send(outfd, SLIP_ESC);
slip_send(outfd, SLIP_ESC_XOFF);
} else {
slip_send(outfd, p[i]);
}
break;
default:
slip_send(outfd, p[i]);
break;
}
}
slip_send(outfd, SLIP_END);
PROGRESS("t");
}
/*
* Read from tun, write to slip.
*/
int
tun_to_serial(int infd, int outfd)
{
struct {
unsigned char inbuf[2000];
} uip;
int size;
if((size = read(infd, uip.inbuf, 2000)) == -1) err(1, "tun_to_serial: read");
write_to_serial(outfd, uip.inbuf, size);
return size;
}
void
stty_telos(int fd)
{
struct termios tty;
speed_t speed = b_rate;
int i;
if(tcflush(fd, TCIOFLUSH) == -1) err(1, "tcflush");
if(tcgetattr(fd, &tty) == -1) err(1, "tcgetattr");
cfmakeraw(&tty);
/* Nonblocking read. */
tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 0;
if (flowcontrol)
tty.c_cflag |= CRTSCTS;
else
tty.c_cflag &= ~CRTSCTS;
tty.c_iflag &= ~IXON;
if(flowcontrol_xonxoff) {
tty.c_iflag |= IXOFF | IXANY;
} else {
tty.c_iflag &= ~IXOFF & ~IXANY;
}
tty.c_cflag &= ~HUPCL;
tty.c_cflag &= ~CLOCAL;
cfsetispeed(&tty, speed);
cfsetospeed(&tty, speed);
if(tcsetattr(fd, TCSAFLUSH, &tty) == -1) err(1, "tcsetattr");
#if 1
/* Nonblocking read and write. */
/* if(fcntl(fd, F_SETFL, O_NONBLOCK) == -1) err(1, "fcntl"); */
tty.c_cflag |= CLOCAL;
if(tcsetattr(fd, TCSAFLUSH, &tty) == -1) err(1, "tcsetattr");
i = TIOCM_DTR;
if(ioctl(fd, TIOCMBIS, &i) == -1) err(1, "ioctl");
#endif
usleep(10*1000); /* Wait for hardware 10ms. */
/* Flush input and output buffers. */
if(tcflush(fd, TCIOFLUSH) == -1) err(1, "tcflush");
}
int
devopen(const char *dev, int flags)
{
char t[1024];
strcpy(t, "/dev/");
strncat(t, dev, sizeof(t) - 5);
return open(t, flags);
}
#ifdef linux
#include <linux/if.h>
#include <linux/if_tun.h>
int
tun_alloc(char *dev, int tap)
{
struct ifreq ifr;
int fd, err;
if( (fd = open("/dev/net/tun", O_RDWR)) < 0 ) {
perror("can not open /dev/net/tun");
return -1;
}
memset(&ifr, 0, sizeof(ifr));
/* Flags: IFF_TUN - TUN device (no Ethernet headers)
* IFF_TAP - TAP device
*
* IFF_NO_PI - Do not provide packet information
*/
ifr.ifr_flags = (tap ? IFF_TAP : IFF_TUN) | IFF_NO_PI;
if(*dev != 0) {
strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name) - 1);
ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
}
if((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0 ) {
close(fd);
fprintf(stderr, "can not tunsetiff to %s (flags=%08x): %s\n", dev, ifr.ifr_flags,
strerror(errno));
return err;
}
/* get resulting tunnel name */
strcpy(dev, ifr.ifr_name);
return fd;
}
#else
int
tun_alloc(char *dev, int tap)
{
return devopen(dev, O_RDWR);
}
#endif
void
cleanup(void)
{
#ifndef __APPLE__
if (timestamp) stamptime();
ssystem("ifconfig %s down", tundev);
#ifndef linux
ssystem("sysctl -w net.ipv6.conf.all.forwarding=1");
#endif
/* ssystem("arp -d %s", ipaddr); */
if (timestamp) stamptime();
ssystem("netstat -nr"
" | awk '{ if ($2 == \"%s\") print \"route delete -net \"$1; }'"
" | sh",
tundev);
#else
{
char * itfaddr = strdup(ipaddr);
char * prefix = index(itfaddr, '/');
if (timestamp) stamptime();
ssystem("ifconfig %s inet6 %s remove", tundev, ipaddr);
if (timestamp) stamptime();
ssystem("ifconfig %s down", tundev);
if ( prefix != NULL ) *prefix = '\0';
ssystem("route delete -inet6 %s", itfaddr);
free(itfaddr);
}
#endif
}
void
sigcleanup(int signo)
{
fprintf(stderr, "signal %d\n", signo);
exit(0); /* exit(0) will call cleanup() */
}
static int got_sigalarm;
void
sigalarm(int signo)
{
got_sigalarm = 1;
return;
}
void
sigalarm_reset()
{
#ifdef linux
#define TIMEOUT (997*1000)
#else
#define TIMEOUT (2451*1000)
#endif
ualarm(TIMEOUT, TIMEOUT);
got_sigalarm = 0;
}
void
ifconf(const char *tundev, const char *ipaddr)
{
#ifdef linux
if (timestamp) stamptime();
ssystem("ifconfig %s inet `hostname` mtu %d up", tundev, devmtu);
if (timestamp) stamptime();
ssystem("ifconfig %s add %s", tundev, ipaddr);
/* radvd needs a link local address for routing */
#if 0
/* fe80::1/64 is good enough */
ssystem("ifconfig %s add fe80::1/64", tundev);
#elif 1
/* Generate a link local address a la sixxs/aiccu */
/* First a full parse, stripping off the prefix length */
{
char lladdr[40];
char c, *ptr=(char *)ipaddr;
uint16_t digit,ai,a[8],cc,scc,i;
for(ai=0; ai<8; ai++) {
a[ai]=0;
}
ai=0;
cc=scc=0;
while((c=*ptr++) != 0) {
if(c=='/') break;
if(c==':') {
if(cc)
scc = ai;
cc = 1;
if(++ai>7) break;
} else {
cc=0;
digit = c-'0';
if (digit > 9)
digit = 10 + (c & 0xdf) - 'A';
a[ai] = (a[ai] << 4) + digit;
}
}
/* Get # elided and shift what's after to the end */
cc=8-ai;
for(i=0;i<cc;i++) {
if ((8-i-cc) <= scc) {
a[7-i] = 0;
} else {
a[7-i] = a[8-i-cc];
a[8-i-cc]=0;
}
}
sprintf(lladdr,"fe80::%x:%x:%x:%x",a[1]&0xfefd,a[2],a[3],a[7]);
if (timestamp) stamptime();
ssystem("ifconfig %s add %s/64", tundev, lladdr);
}
#endif /* link local */
#elif defined(__APPLE__)
{
char * itfaddr = strdup(ipaddr);
char * prefix = index(itfaddr, '/');
if ( prefix != NULL ) {
*prefix = '\0';
prefix++;
} else {
prefix = "64";
}
if (timestamp) stamptime();
ssystem("ifconfig %s inet6 mtu %d up", tundev, devmtu);
if (timestamp) stamptime();
ssystem("ifconfig %s inet6 %s add", tundev, ipaddr );
if (timestamp) stamptime();
ssystem("sysctl -w net.inet6.ip6.forwarding=1");
free(itfaddr);
}
#else
if (timestamp) stamptime();
ssystem("ifconfig %s inet `hostname` %s mtu %d up", tundev, ipaddr, devmtu);
if (timestamp) stamptime();
ssystem("sysctl -w net.inet.ip.forwarding=1");
#endif /* !linux */
if (timestamp) stamptime();
ssystem("ifconfig %s\n", tundev);
}
int
main(int argc, char **argv)
{
int c;
int tunfd, maxfd;
int ret;
fd_set rset, wset;
FILE *inslip;
const char *siodev = NULL;
const char *host = NULL;
const char *port = NULL;
const char *prog;
int baudrate = -2;
int ipa_enable = 0;
int tap = 0;
slipfd = 0;
prog = argv[0];
setvbuf(stdout, NULL, _IOLBF, 0); /* Line buffered output. */
while((c = getopt(argc, argv, "B:HILPhXM:s:t:v::d::a:p:T")) != -1) {
switch(c) {
case 'B':
baudrate = atoi(optarg);
break;
case 'H':
flowcontrol=1;
break;
case 'X':
flowcontrol_xonxoff=1;
break;
case 'L':
timestamp=1;
break;
case 'M':
devmtu=atoi(optarg);
if(devmtu < MIN_DEVMTU) {
devmtu = MIN_DEVMTU;
}
case 'P':
showprogress=1;
break;
case 's':
if(strncmp("/dev/", optarg, 5) == 0) {
siodev = optarg + 5;
} else {
siodev = optarg;
}
break;
case 'I':
ipa_enable = 1;
fprintf(stderr, "Will inquire about IP address using IPA=\n");
break;
case 't':
if(strncmp("/dev/", optarg, 5) == 0) {
strncpy(tundev, optarg + 5, sizeof(tundev) - 1);
} else {
strncpy(tundev, optarg, sizeof(tundev) - 1);
}
tundev[sizeof(tundev) - 1] = '\0';
break;
case 'a':
host = optarg;
break;
case 'p':
port = optarg;
break;
case 'd':
basedelay = 10;
if (optarg) basedelay = atoi(optarg);
break;
case 'v':
verbose = 2;
if (optarg) verbose = atoi(optarg);
break;
case 'T':
tap = 1;
break;
case '?':
case 'h':
default:
fprintf(stderr,"usage: %s [options] ipaddress\n", prog);
fprintf(stderr,"example: tunslip6 -L -v2 -s ttyUSB1 fd00::1/64\n");
fprintf(stderr,"Options are:\n");
#ifndef __APPLE__
fprintf(stderr," -B baudrate 9600,19200,38400,57600,115200 (default),230400,460800,921600\n");
#else
fprintf(stderr," -B baudrate 9600,19200,38400,57600,115200 (default),230400\n");
#endif
fprintf(stderr, " -P Show progress\n");
fprintf(stderr, " -H Hardware CTS/RTS flow control (default disabled)\n");
fprintf(stderr, " -I Inquire IP address\n");
fprintf(stderr, " -X Software XON/XOFF flow control (default disabled)\n");
fprintf(stderr, " -L Log output format (adds time stamps)\n");
fprintf(stderr, " -s siodev Serial device (default /dev/ttyUSB0)\n");
fprintf(stderr, " -M Interface MTU (default and min: 1280)\n");
fprintf(stderr, " -T Make tap interface (default is tun interface)\n");
fprintf(stderr, " -t tundev Name of interface (default tap0 or tun0)\n");
#ifdef __APPLE__
fprintf(stderr, " -v level Verbosity level\n");
#else
fprintf(stderr, " -v[level] Verbosity level\n");
#endif
fprintf(stderr, " -v0 No messages\n");
fprintf(stderr, " -v1 Encapsulated SLIP debug messages\n");
fprintf(stderr, " -v2 Printable strings after they are received (default)\n");
fprintf(stderr, " -v3 Printable strings and SLIP packet notifications\n");
fprintf(stderr, " -v4 All printable characters as they are received\n");
fprintf(stderr, " -v5 All SLIP packets in hex\n");
#ifndef __APPLE__
fprintf(stderr, " -v Equivalent to -v2\n");
#endif
#ifdef __APPLE__
fprintf(stderr, " -d basedelay Minimum delay between outgoing SLIP packets.\n");
#else
fprintf(stderr, " -d[basedelay] Minimum delay between outgoing SLIP packets.\n");
#endif
fprintf(stderr, " Actual delay is basedelay*(#6LowPAN fragments) milliseconds.\n");
#ifndef __APPLE__
fprintf(stderr, " -d is equivalent to -d10.\n");
#endif
fprintf(stderr, " -a serveraddr \n");
fprintf(stderr, " -p serverport \n");
exit(1);
break;
}
}
argc -= (optind - 1);
argv += (optind - 1);
if(argc != 2 && argc != 3) {
err(1, "usage: %s [-B baudrate] [-P] [-H] [-I] [-X] [-L] [-s siodev] [-M] [-T] [-t tundev] "
#ifdef __APPLE__
"[-v level] [-d basedelay] "
#else
"[-v [level]] [-d [basedelay]] "
#endif
"[-a serveraddr] [-p serverport] ipaddress", prog);
}
ipaddr = argv[1];
if(baudrate != -2) { /* -2: use default baudrate */
b_rate = select_baudrate(baudrate);
if(b_rate == 0) {
err(1, "unknown baudrate %d", baudrate);
}
}
#ifdef __APPLE__
if(*tundev == '\0') {
/* Use default. */
if(tap) {
strcpy(tundev, "tap0");
} else {
strcpy(tundev, "tun0");
}
}
#endif
if(host != NULL) {
struct addrinfo hints, *servinfo, *p;
int rv;
char s[INET6_ADDRSTRLEN];
if(port == NULL) {
port = "60001";
}
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if((rv = getaddrinfo(host, port, &hints, &servinfo)) != 0) {
err(1, "getaddrinfo: %s", gai_strerror(rv));
}
/* loop through all the results and connect to the first we can */
for(p = servinfo; p != NULL; p = p->ai_next) {
if((slipfd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1) {
perror("client: socket");
continue;
}
if(connect(slipfd, p->ai_addr, p->ai_addrlen) == -1) {
close(slipfd);
perror("client: connect");
continue;
}
break;
}
if(p == NULL) {
err(1, "can't connect to ``%s:%s''", host, port);
}
fcntl(slipfd, F_SETFL, O_NONBLOCK);
inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
s, sizeof(s));
fprintf(stderr, "slip connected to ``%s:%s''\n", s, port);
/* all done with this structure */
freeaddrinfo(servinfo);
} else {
if(siodev != NULL) {
slipfd = devopen(siodev, O_RDWR | O_NONBLOCK);
if(slipfd == -1) {
err(1, "can't open siodev ``/dev/%s''", siodev);
}
} else {
static const char *siodevs[] = {
"ttyUSB0", "cuaU0", "ucom0" /* linux, fbsd6, fbsd5 */
};
int i;
for(i = 0; i < 3; i++) {
siodev = siodevs[i];
slipfd = devopen(siodev, O_RDWR | O_NONBLOCK);
if(slipfd != -1) {
break;
}
}
if(slipfd == -1) {
err(1, "can't open siodev");
}
}
if (timestamp) stamptime();
fprintf(stderr, "********SLIP started on ``/dev/%s''\n", siodev);
stty_telos(slipfd);
}
slip_send(slipfd, SLIP_END);
inslip = fdopen(slipfd, "r");
if(inslip == NULL) err(1, "main: fdopen");
tunfd = tun_alloc(tundev, tap);
if(tunfd == -1) err(1, "main: open /dev/tun");
if (timestamp) stamptime();
fprintf(stderr, "opened %s device ``/dev/%s''\n",
tap ? "tap" : "tun", tundev);
atexit(cleanup);
signal(SIGHUP, sigcleanup);
signal(SIGTERM, sigcleanup);
signal(SIGINT, sigcleanup);
signal(SIGALRM, sigalarm);
ifconf(tundev, ipaddr);
while(1) {
maxfd = 0;
FD_ZERO(&rset);
FD_ZERO(&wset);
if(got_sigalarm && ipa_enable) {
/* Send "?IPA". */
slip_send(slipfd, '?');
slip_send(slipfd, 'I');
slip_send(slipfd, 'P');
slip_send(slipfd, 'A');
slip_send(slipfd, SLIP_END);
got_sigalarm = 0;
}
if(!slip_empty()) { /* Anything to flush? */
FD_SET(slipfd, &wset);
}
FD_SET(slipfd, &rset); /* Read from slip ASAP! */
if(slipfd > maxfd) maxfd = slipfd;
/* We only have one packet at a time queued for slip output. */
if(slip_empty()) {
FD_SET(tunfd, &rset);
if(tunfd > maxfd) maxfd = tunfd;
}
ret = select(maxfd + 1, &rset, &wset, NULL, NULL);
if(ret == -1 && errno != EINTR) {
err(1, "select");
} else if(ret > 0) {
if(FD_ISSET(slipfd, &rset)) {
serial_to_tun(inslip, tunfd);
}
if(FD_ISSET(slipfd, &wset)) {
slip_flushbuf(slipfd);
if(ipa_enable) sigalarm_reset();
}
/* Optional delay between outgoing packets */
/* Base delay times number of 6lowpan fragments to be sent */
if(delaymsec) {
struct timeval tv;
int dmsec;
gettimeofday(&tv, NULL) ;
dmsec=(tv.tv_sec-delaystartsec)*1000+tv.tv_usec/1000-delaystartmsec;
if(dmsec<0) delaymsec=0;
if(dmsec>delaymsec) delaymsec=0;
}
if(delaymsec==0) {
if(slip_empty() && FD_ISSET(tunfd, &rset)) {
tun_to_serial(tunfd, slipfd);
slip_flushbuf(slipfd);
if(ipa_enable) sigalarm_reset();
if(basedelay) {
struct timeval tv;
gettimeofday(&tv, NULL) ;
// delaymsec=basedelay*(1+(size/120));//multiply by # of 6lowpan packets?
delaymsec=basedelay;
delaystartsec =tv.tv_sec;
delaystartmsec=tv.tv_usec/1000;
}
}
}
}
}
}
|
312083.c | /*
Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the terms of version 2.1 of the GNU Lesser General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it would be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Further, this software is distributed without any warranty that it is
free of the rightful claim of any third person regarding infringement
or the like. Any license provided herein, whether implied or
otherwise, applies only to this software file. Patent licenses, if
any, provided herein do not apply to combinations of this program with
other software, or any other product whatsoever.
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
USA.
Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky,
Mountain View, CA 94043, or:
http://www.sgi.com
For further information regarding this notice, see:
http://oss.sgi.com/projects/GenInfo/NoticeExplan
*/
#pragma ident "@(#) libu/util/unpack_c.c 92.1 07/07/99 13:18:33"
#include <fortran.h>
#include <liberrno.h>
/*
* UNPACK Unpack full 64-bit words into partial words
*
* UNPACK takes 64-bit words and extracts 1-, 2-, 4-, 8-,
* 16-, or 32-bit quantities and places them right-justified
* into 64-bit words. The quantities will optionally be
* sign-extended.
*
* CALL UNPACK ( P, NBITS, U, COUNT [,SEF] )
*
* On entry:
*
* NBITS Size of quantities to extract from each
* packed word. NBITS must be a power of two
* (1, 2, 4, 8, 16, or 32).
*
* P Vector of 64-bit words to be unpacked
*
* COUNT Number of partial word quantities to unpack
*
* SEF Optional sign extension flag. If .TRUE.,
* items will be sign extended. If omitted or
* .FALSE., items will not be sign extended.
*
* On exit:
*
* U Vector of unpacked data
*
* (COUNT * NBITS) need not be a full-word multiple (i.e.,
* a multiple of 64).
*/
void
UNPACK(
_f_int *p,
_f_int *nbits,
_f_int *u,
_f_int *count,
_f_log *sef
)
{
register short sefl; /* Sign extension flag */
register int nb;
register int ni;
#ifdef _UNICOS
if (_numargs() < 4)
_lerror(_LELVL_ABORT, FEPCKARG);
sefl = (_numargs() > 4) ? _lvtob(*sef) : 0;
#else
sefl = _lvtob(*sef);
#endif
nb = *nbits;
ni = *count;
if (nb < 0)
_lerror(_LELVL_ABORT, FEPCKNEG);
if (nb == 0)
_lerror(_LELVL_ABORT, FEPCKPW2);
if (ni > 0) {
register short cpw; /* Chunks per word */
register short remr; /* Remainder */
register int i;
register int items; /* Number of full-word items */
register long mask; /* Mask for each item */
register long sehw; /* Sign extension helper word */
register unsigned long word; /* Scratch word */
cpw = 64 / nb; /* Chunks per word */
items = (ni * nb) >> 6; /* (count * nbits) / 64 */
remr = (ni * nb) & 077; /* Remainder */
mask = (1 << nb) - 1;
sehw = sefl << (nb - 1);
switch (nb) {
case 32:
#pragma _CRI ivdep
for (i = 0; i < items; i++) {
word = *p++;
*u++ = ((word >> 32) ^ sehw) - sehw;
*u++ = ((word & mask) ^ sehw) - sehw;
}
break;
case 16:
#pragma _CRI ivdep
for (i = 0; i < items; i++) {
word = *p++;
*u++ = ((word >> 48) ^ sehw) - sehw;
*u++ = (((word >> 32) & mask) ^ sehw) - sehw;
*u++ = (((word >> 16) & mask) ^ sehw) - sehw;
*u++ = ((word & mask) ^ sehw) - sehw;
}
break;
case 8:
#pragma _CRI ivdep
for (i = 0; i < items; i++) {
word = *p++;
*u++ = ((word >> 56) ^ sehw) - sehw;
*u++ = (((word >> 48) & mask) ^ sehw) - sehw;
*u++ = (((word >> 40) & mask) ^ sehw) - sehw;
*u++ = (((word >> 32) & mask) ^ sehw) - sehw;
*u++ = (((word >> 24) & mask) ^ sehw) - sehw;
*u++ = (((word >> 16) & mask) ^ sehw) - sehw;
*u++ = (((word >> 8) & mask) ^ sehw) - sehw;
*u++ = ((word & mask) ^ sehw) - sehw;
}
break;
case 4:
case 2:
case 1:
for (i = 0; i < items; i++) {
register short shft;
register short j;
word = *p++;
shft = 64 - nb;
#pragma _CRI shortloop
for (j = 0; j < cpw; j++) {
*u++ = (((word >> shft) & mask) ^ sehw) - sehw;
shft = shft - nb;
}
}
break;
default:
_lerror(_LELVL_ABORT, FEPCKPW2);
break;
} /* switch */
if (remr > 0) {
register short shft;
register short j;
word = *p;
shft = 64 - nb;
#pragma _CRI novector
for (j = remr; j > 0; j = j - nb) {
*u++ = (((word >> shft) & mask) ^ sehw) - sehw;
shft = shft - nb;
}
}
}
return;
}
|
194359.c | /*
* Windows and DOS version functions
*
* Copyright 1997 Marcus Meissner
* Copyright 1998 Patrik Stridvall
* Copyright 1998, 2003 Andreas Mohr
* Copyright 1997, 2003 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "wine/debug.h"
#include "ntdll_misc.h"
#include "ddk/wdm.h"
WINE_DEFAULT_DEBUG_CHANNEL(ver);
typedef enum
{
WIN20, /* Windows 2.0 */
WIN30, /* Windows 3.0 */
WIN31, /* Windows 3.1 */
WIN95, /* Windows 95 */
WIN98, /* Windows 98 */
WINME, /* Windows Me */
NT351, /* Windows NT 3.51 */
NT40, /* Windows NT 4.0 */
NT2K, /* Windows 2000 */
WINXP, /* Windows XP */
WINXP64, /* Windows XP 64-bit */
WIN2K3, /* Windows 2003 */
WINVISTA,/* Windows Vista */
WIN2K8, /* Windows 2008 */
WIN2K8R2,/* Windows 2008 R2 */
WIN7, /* Windows 7 */
WIN8, /* Windows 8 */
WIN81, /* Windows 8.1 */
WIN10, /* Windows 10 */
NB_WINDOWS_VERSIONS
} WINDOWS_VERSION;
/* FIXME: compare values below with original and fix.
* An *excellent* win9x version page (ALL versions !)
* can be found at www.mdgx.com/ver.htm */
static const RTL_OSVERSIONINFOEXW VersionData[NB_WINDOWS_VERSIONS] =
{
/* WIN20 FIXME: verify values */
{
sizeof(RTL_OSVERSIONINFOEXW), 2, 0, 0, VER_PLATFORM_WIN32s,
{'W','i','n','3','2','s',' ','1','.','3',0},
0, 0, 0, 0, 0
},
/* WIN30 FIXME: verify values */
{
sizeof(RTL_OSVERSIONINFOEXW), 3, 0, 0, VER_PLATFORM_WIN32s,
{'W','i','n','3','2','s',' ','1','.','3',0},
0, 0, 0, 0, 0
},
/* WIN31 */
{
sizeof(RTL_OSVERSIONINFOEXW), 3, 10, 0, VER_PLATFORM_WIN32s,
{'W','i','n','3','2','s',' ','1','.','3',0},
0, 0, 0, 0, 0
},
/* WIN95 */
{
/* Win95: 4, 0, 0x40003B6, ""
* Win95sp1: 4, 0, 0x40003B6, " A " (according to doc)
* Win95osr2: 4, 0, 0x4000457, " B " (according to doc)
* Win95osr2.1: 4, 3, 0x40304BC, " B " (according to doc)
* Win95osr2.5: 4, 3, 0x40304BE, " C " (according to doc)
* Win95a/b can be discerned via regkey SubVersionNumber
*/
sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x40003B6, VER_PLATFORM_WIN32_WINDOWS,
{0},
0, 0, 0, 0, 0
},
/* WIN98 (second edition) */
{
/* Win98: 4, 10, 0x40A07CE, " " 4.10.1998
* Win98SE: 4, 10, 0x40A08AE, " A " 4.10.2222
*/
sizeof(RTL_OSVERSIONINFOEXW), 4, 10, 0x40A08AE, VER_PLATFORM_WIN32_WINDOWS,
{' ','A',' ',0},
0, 0, 0, 0, 0
},
/* WINME */
{
sizeof(RTL_OSVERSIONINFOEXW), 4, 90, 0x45A0BB8, VER_PLATFORM_WIN32_WINDOWS,
{' ',0},
0, 0, 0, 0, 0
},
/* NT351 */
{
sizeof(RTL_OSVERSIONINFOEXW), 3, 51, 0x421, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','5',0},
5, 0, 0, VER_NT_WORKSTATION, 0
},
/* NT40 */
{
sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x565, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','6','a',0},
6, 0, 0, VER_NT_WORKSTATION, 0
},
/* NT2K */
{
sizeof(RTL_OSVERSIONINFOEXW), 5, 0, 0x893, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','4',0},
4, 0, 0, VER_NT_WORKSTATION, 30 /* FIXME: Great, a reserved field with a value! */
},
/* WINXP */
{
sizeof(RTL_OSVERSIONINFOEXW), 5, 1, 0xA28, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','3',0},
3, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 30 /* FIXME: Great, a reserved field with a value! */
},
/* WINXP64 */
{
sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
/* WIN2K3 */
{
sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
},
/* WINVISTA */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
/* WIN2K8 */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
},
/* WIN7 */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','1',0},
1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
/* WIN2K8R2 */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
{'S','e','r','v','i','c','e',' ','P','a','c','k',' ','1',0},
1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
},
/* WIN8 */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 2, 0x23F0, VER_PLATFORM_WIN32_NT,
{0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
/* WIN81 */
{
sizeof(RTL_OSVERSIONINFOEXW), 6, 3, 0x2580, VER_PLATFORM_WIN32_NT,
{0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
/* WIN10 */
{
sizeof(RTL_OSVERSIONINFOEXW), 10, 0, 0x4563, VER_PLATFORM_WIN32_NT,
{0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
},
};
static const struct { WCHAR name[12]; WINDOWS_VERSION ver; } version_names[] =
{
{ {'w','i','n','2','0',0}, WIN20 },
{ {'w','i','n','3','0',0}, WIN30 },
{ {'w','i','n','3','1',0}, WIN31 },
{ {'w','i','n','9','5',0}, WIN95 },
{ {'w','i','n','9','8',0}, WIN98 },
{ {'w','i','n','m','e',0}, WINME },
{ {'n','t','3','5','1',0}, NT351 },
{ {'n','t','4','0',0}, NT40 },
{ {'w','i','n','2','0','0','0',0}, NT2K },
{ {'w','i','n','2','k',0}, NT2K },
{ {'n','t','2','k',0}, NT2K },
{ {'n','t','2','0','0','0',0}, NT2K },
{ {'w','i','n','x','p',0}, WINXP },
{ {'w','i','n','x','p','6','4',0}, WINXP64 },
{ {'w','i','n','2','0','0','3',0}, WIN2K3 },
{ {'w','i','n','2','k','3',0}, WIN2K3 },
{ {'v','i','s','t','a',0}, WINVISTA },
{ {'w','i','n','v','i','s','t','a',0}, WINVISTA },
{ {'w','i','n','2','0','0','8',0}, WIN2K8 },
{ {'w','i','n','2','k','8',0}, WIN2K8 },
{ {'w','i','n','2','0','0','8','r','2',0}, WIN2K8R2 },
{ {'w','i','n','2','k','8','r','2',0}, WIN2K8R2 },
{ {'w','i','n','7',0}, WIN7 },
{ {'w','i','n','8',0}, WIN8 },
{ {'w','i','n','8','1',0}, WIN81 },
{ {'w','i','n','1','0',0}, WIN10 },
};
/* initialized to null so that we crash if we try to retrieve the version too early at startup */
static const RTL_OSVERSIONINFOEXW *current_version;
/**********************************************************************
* get_nt_registry_version
*
* Fetch the version information from the NT-style registry keys.
*/
static BOOL get_nt_registry_version( RTL_OSVERSIONINFOEXW *version )
{
static const WCHAR version_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
static const WCHAR service_pack_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'W','i','n','d','o','w','s',0};
static const WCHAR product_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'P','r','o','d','u','c','t','O','p','t','i','o','n','s',0};
static const WCHAR CurrentBuildNumberW[] = {'C','u','r','r','e','n','t','B','u','i','l','d','N','u','m','b','e','r',0};
static const WCHAR CSDVersionW[] = {'C','S','D','V','e','r','s','i','o','n',0};
static const WCHAR CurrentVersionW[] = {'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
static const WCHAR ProductTypeW[] = {'P','r','o','d','u','c','t','T','y','p','e',0};
static const WCHAR WinNTW[] = {'W','i','n','N','T',0};
static const WCHAR ServerNTW[] = {'S','e','r','v','e','r','N','T',0};
static const WCHAR LanmanNTW[] = {'L','a','n','m','a','n','N','T',0};
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW, valueW;
HANDLE hkey, hkey2;
char tmp[64];
DWORD count;
BOOL ret = FALSE;
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, version_keyW );
if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
memset( version, 0, sizeof(*version) );
RtlInitUnicodeString( &valueW, CurrentVersionW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *p, *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
p = wcschr( str, '.' );
if (p)
{
*p++ = 0;
version->dwMinorVersion = wcstoul( p, NULL, 10 );
}
version->dwMajorVersion = wcstoul( str, NULL, 10 );
}
if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
{
ret = TRUE;
version->dwPlatformId = VER_PLATFORM_WIN32_NT;
/* get build number */
RtlInitUnicodeString( &valueW, CurrentBuildNumberW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
version->dwBuildNumber = wcstoul( str, NULL, 10 );
}
/* get version description */
RtlInitUnicodeString( &valueW, CSDVersionW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
memcpy( version->szCSDVersion, info->Data, len );
version->szCSDVersion[len / sizeof(WCHAR)] = 0;
}
/* get service pack version */
RtlInitUnicodeString( &nameW, service_pack_keyW );
if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
{
RtlInitUnicodeString( &valueW, CSDVersionW );
if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp), &count ))
{
if (info->DataLength >= sizeof(DWORD))
{
DWORD dw = *(DWORD *)info->Data;
version->wServicePackMajor = LOWORD(dw) >> 8;
version->wServicePackMinor = LOWORD(dw) & 0xff;
}
}
NtClose( hkey2 );
}
/* get product type */
RtlInitUnicodeString( &nameW, product_keyW );
if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
{
RtlInitUnicodeString( &valueW, ProductTypeW );
if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
if (!wcsicmp( str, WinNTW )) version->wProductType = VER_NT_WORKSTATION;
else if (!wcsicmp( str, LanmanNTW )) version->wProductType = VER_NT_DOMAIN_CONTROLLER;
else if (!wcsicmp( str, ServerNTW )) version->wProductType = VER_NT_SERVER;
}
NtClose( hkey2 );
}
/* FIXME: get wSuiteMask */
}
NtClose( hkey );
return ret;
}
/**********************************************************************
* get_win9x_registry_version
*
* Fetch the version information from the Win9x-style registry keys.
*/
static BOOL get_win9x_registry_version( RTL_OSVERSIONINFOEXW *version )
{
static const WCHAR version_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
static const WCHAR VersionNumberW[] = {'V','e','r','s','i','o','n','N','u','m','b','e','r',0};
static const WCHAR SubVersionNumberW[] = {'S','u','b','V','e','r','s','i','o','n','N','u','m','b','e','r',0};
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW, valueW;
HANDLE hkey;
char tmp[64];
DWORD count;
BOOL ret = FALSE;
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, version_keyW );
if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
memset( version, 0, sizeof(*version) );
RtlInitUnicodeString( &valueW, VersionNumberW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *p, *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
p = wcschr( str, '.' );
if (p) *p++ = 0;
version->dwMajorVersion = wcstoul( str, NULL, 10 );
if (p)
{
str = p;
p = wcschr( str, '.' );
if (p)
{
*p++ = 0;
version->dwBuildNumber = wcstoul( p, NULL, 10 );
}
version->dwMinorVersion = wcstoul( str, NULL, 10 );
}
/* build number contains version too on Win9x */
version->dwBuildNumber |= MAKEWORD( version->dwMinorVersion, version->dwMajorVersion ) << 16;
}
if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
{
ret = TRUE;
version->dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;
RtlInitUnicodeString( &valueW, SubVersionNumberW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
memcpy( version->szCSDVersion, info->Data, len );
version->szCSDVersion[len / sizeof(WCHAR)] = 0;
}
}
NtClose( hkey );
return ret;
}
/**********************************************************************
* parse_win_version
*
* Parse the contents of the Version key.
*/
static BOOL parse_win_version( HANDLE hkey )
{
static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
UNICODE_STRING valueW;
WCHAR *name, tmp[64];
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
DWORD i, count;
RtlInitUnicodeString( &valueW, VersionW );
if (NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp) - sizeof(WCHAR), &count ))
return FALSE;
name = (WCHAR *)info->Data;
name[info->DataLength / sizeof(WCHAR)] = 0;
for (i = 0; i < ARRAY_SIZE(version_names); i++)
{
if (wcscmp( version_names[i].name, name )) continue;
current_version = &VersionData[version_names[i].ver];
TRACE( "got win version %s\n", debugstr_w(version_names[i].name) );
return TRUE;
}
ERR( "Invalid Windows version value %s specified in config file.\n", debugstr_w(name) );
return FALSE;
}
/**********************************************************************
* version_init
*/
void version_init(void)
{
static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e',0};
static const WCHAR appdefaultsW[] = {'A','p','p','D','e','f','a','u','l','t','s','\\',0};
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
HANDLE root, hkey, config_key;
BOOL got_win_ver = FALSE;
const WCHAR *p, *appname = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
WCHAR appversion[MAX_PATH+20];
current_version = &VersionData[WIN10];
RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
attr.Length = sizeof(attr);
attr.RootDirectory = root;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, configW );
/* @@ Wine registry key: HKCU\Software\Wine */
if (NtOpenKey( &config_key, KEY_ALL_ACCESS, &attr )) config_key = 0;
NtClose( root );
if (!config_key) goto done;
/* open AppDefaults\\appname key */
if ((p = wcsrchr( appname, '/' ))) appname = p + 1;
if ((p = wcsrchr( appname, '\\' ))) appname = p + 1;
wcscpy( appversion, appdefaultsW );
wcscat( appversion, appname );
RtlInitUnicodeString( &nameW, appversion );
attr.RootDirectory = config_key;
/* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe */
if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
{
TRACE( "getting version from %s\n", debugstr_w(appversion) );
got_win_ver = parse_win_version( hkey );
NtClose( hkey );
}
if (!got_win_ver)
{
TRACE( "getting default version\n" );
got_win_ver = parse_win_version( config_key );
}
NtClose( config_key );
done:
if (!got_win_ver)
{
static RTL_OSVERSIONINFOEXW registry_version;
TRACE( "getting registry version\n" );
if (get_nt_registry_version( ®istry_version ) ||
get_win9x_registry_version( ®istry_version ))
current_version = ®istry_version;
}
NtCurrentTeb()->Peb->OSMajorVersion = current_version->dwMajorVersion;
NtCurrentTeb()->Peb->OSMinorVersion = current_version->dwMinorVersion;
NtCurrentTeb()->Peb->OSBuildNumber = current_version->dwBuildNumber;
NtCurrentTeb()->Peb->OSPlatformId = current_version->dwPlatformId;
TRACE( "got %d.%d platform %d build %x name %s service pack %d.%d product %d\n",
current_version->dwMajorVersion, current_version->dwMinorVersion,
current_version->dwPlatformId, current_version->dwBuildNumber,
debugstr_w(current_version->szCSDVersion),
current_version->wServicePackMajor, current_version->wServicePackMinor,
current_version->wProductType );
}
/***********************************************************************
* RtlGetProductInfo (NTDLL.@)
*
* Gives info about the current Windows product type, in a format compatible
* with the given Windows version
*
* Returns TRUE if the input is valid, FALSE otherwise
*/
BOOLEAN WINAPI RtlGetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion,
DWORD dwSpMinorVersion, PDWORD pdwReturnedProductType)
{
TRACE("(%d, %d, %d, %d, %p)\n", dwOSMajorVersion, dwOSMinorVersion,
dwSpMajorVersion, dwSpMinorVersion, pdwReturnedProductType);
if (!pdwReturnedProductType)
return FALSE;
if (dwOSMajorVersion < 6)
{
*pdwReturnedProductType = PRODUCT_UNDEFINED;
return FALSE;
}
if (current_version->wProductType == VER_NT_WORKSTATION)
*pdwReturnedProductType = PRODUCT_ULTIMATE_N;
else
*pdwReturnedProductType = PRODUCT_STANDARD_SERVER;
return TRUE;
}
/***********************************************************************
* RtlGetVersion (NTDLL.@)
*/
NTSTATUS WINAPI RtlGetVersion( RTL_OSVERSIONINFOEXW *info )
{
info->dwMajorVersion = current_version->dwMajorVersion;
info->dwMinorVersion = current_version->dwMinorVersion;
info->dwBuildNumber = current_version->dwBuildNumber;
info->dwPlatformId = current_version->dwPlatformId;
wcscpy( info->szCSDVersion, current_version->szCSDVersion );
if(info->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW))
{
info->wServicePackMajor = current_version->wServicePackMajor;
info->wServicePackMinor = current_version->wServicePackMinor;
info->wSuiteMask = current_version->wSuiteMask;
info->wProductType = current_version->wProductType;
}
return STATUS_SUCCESS;
}
/******************************************************************************
* RtlGetNtVersionNumbers (NTDLL.@)
*
* Get the version numbers of the run time library.
*
* PARAMS
* major [O] Destination for the Major version
* minor [O] Destination for the Minor version
* build [O] Destination for the Build version
*
* RETURNS
* Nothing.
*
* NOTES
* Introduced in Windows XP (NT5.1)
*/
void WINAPI RtlGetNtVersionNumbers( LPDWORD major, LPDWORD minor, LPDWORD build )
{
if (major) *major = current_version->dwMajorVersion;
if (minor) *minor = current_version->dwMinorVersion;
/* FIXME: Does anybody know the real formula? */
if (build) *build = (0xF0000000 | current_version->dwBuildNumber);
}
/******************************************************************************
* RtlGetNtProductType (NTDLL.@)
*/
BOOLEAN WINAPI RtlGetNtProductType( LPDWORD type )
{
if (type) *type = current_version->wProductType;
return TRUE;
}
static inline UCHAR version_update_condition(UCHAR *last_condition, UCHAR condition)
{
switch (*last_condition)
{
case 0:
*last_condition = condition;
break;
case VER_EQUAL:
if (condition >= VER_EQUAL && condition <= VER_LESS_EQUAL)
{
*last_condition = condition;
return condition;
}
break;
case VER_GREATER:
case VER_GREATER_EQUAL:
if (condition >= VER_EQUAL && condition <= VER_GREATER_EQUAL)
return condition;
break;
case VER_LESS:
case VER_LESS_EQUAL:
if (condition == VER_EQUAL || (condition >= VER_LESS && condition <= VER_LESS_EQUAL))
return condition;
break;
}
if (!condition) *last_condition |= 0x10;
return *last_condition & 0xf;
}
static inline NTSTATUS version_compare_values(ULONG left, ULONG right, UCHAR condition)
{
switch (condition) {
case VER_EQUAL:
if (left != right) return STATUS_REVISION_MISMATCH;
break;
case VER_GREATER:
if (left <= right) return STATUS_REVISION_MISMATCH;
break;
case VER_GREATER_EQUAL:
if (left < right) return STATUS_REVISION_MISMATCH;
break;
case VER_LESS:
if (left >= right) return STATUS_REVISION_MISMATCH;
break;
case VER_LESS_EQUAL:
if (left > right) return STATUS_REVISION_MISMATCH;
break;
default:
return STATUS_REVISION_MISMATCH;
}
return STATUS_SUCCESS;
}
/******************************************************************************
* RtlVerifyVersionInfo (NTDLL.@)
*/
NTSTATUS WINAPI RtlVerifyVersionInfo( const RTL_OSVERSIONINFOEXW *info,
DWORD dwTypeMask, DWORDLONG dwlConditionMask )
{
RTL_OSVERSIONINFOEXW ver;
NTSTATUS status;
TRACE("(%p,0x%x,0x%s)\n", info, dwTypeMask, wine_dbgstr_longlong(dwlConditionMask));
ver.dwOSVersionInfoSize = sizeof(ver);
if ((status = RtlGetVersion( &ver )) != STATUS_SUCCESS) return status;
if(!(dwTypeMask && dwlConditionMask)) return STATUS_INVALID_PARAMETER;
if(dwTypeMask & VER_PRODUCT_TYPE)
{
status = version_compare_values(ver.wProductType, info->wProductType, dwlConditionMask >> 7*3 & 0x07);
if (status != STATUS_SUCCESS)
return status;
}
if(dwTypeMask & VER_SUITENAME)
switch(dwlConditionMask >> 6*3 & 0x07)
{
case VER_AND:
if((info->wSuiteMask & ver.wSuiteMask) != info->wSuiteMask)
return STATUS_REVISION_MISMATCH;
break;
case VER_OR:
if(!(info->wSuiteMask & ver.wSuiteMask) && info->wSuiteMask)
return STATUS_REVISION_MISMATCH;
break;
default:
return STATUS_INVALID_PARAMETER;
}
if(dwTypeMask & VER_PLATFORMID)
{
status = version_compare_values(ver.dwPlatformId, info->dwPlatformId, dwlConditionMask >> 3*3 & 0x07);
if (status != STATUS_SUCCESS)
return status;
}
if(dwTypeMask & VER_BUILDNUMBER)
{
status = version_compare_values(ver.dwBuildNumber, info->dwBuildNumber, dwlConditionMask >> 2*3 & 0x07);
if (status != STATUS_SUCCESS)
return status;
}
if(dwTypeMask & (VER_MAJORVERSION|VER_MINORVERSION|VER_SERVICEPACKMAJOR|VER_SERVICEPACKMINOR))
{
unsigned char condition, last_condition = 0;
BOOLEAN do_next_check = TRUE;
if(dwTypeMask & VER_MAJORVERSION)
{
condition = version_update_condition(&last_condition, dwlConditionMask >> 1*3 & 0x07);
status = version_compare_values(ver.dwMajorVersion, info->dwMajorVersion, condition);
do_next_check = (ver.dwMajorVersion == info->dwMajorVersion) &&
((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
}
if((dwTypeMask & VER_MINORVERSION) && do_next_check)
{
condition = version_update_condition(&last_condition, dwlConditionMask >> 0*3 & 0x07);
status = version_compare_values(ver.dwMinorVersion, info->dwMinorVersion, condition);
do_next_check = (ver.dwMinorVersion == info->dwMinorVersion) &&
((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
}
if((dwTypeMask & VER_SERVICEPACKMAJOR) && do_next_check)
{
condition = version_update_condition(&last_condition, dwlConditionMask >> 5*3 & 0x07);
status = version_compare_values(ver.wServicePackMajor, info->wServicePackMajor, condition);
do_next_check = (ver.wServicePackMajor == info->wServicePackMajor) &&
((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
}
if((dwTypeMask & VER_SERVICEPACKMINOR) && do_next_check)
{
condition = version_update_condition(&last_condition, dwlConditionMask >> 4*3 & 0x07);
status = version_compare_values(ver.wServicePackMinor, info->wServicePackMinor, condition);
}
if (status != STATUS_SUCCESS)
return status;
}
return STATUS_SUCCESS;
}
|
175597.c | /* -*- Mode: C; tab-width: 4 -*- */
/* stairs --- Infinite Stairs, and Escher-like scene. */
#if 0
static const char sccsid[] = "@(#)stairs.c 4.07 97/11/24 xlockmore";
#endif
/*-
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation.
*
* This file is provided AS IS with no warranties of any kind. The author
* shall have no liability with respect to the infringement of copyrights,
* trade secrets or any patents by this file or any part thereof. In no
* event will the author be liable for any lost revenue or profits or
* other special, indirect and consequential damages.
*
* This mode shows some interesting scenes that are impossible OR very
* weird to build in the real universe. Much of the scenes are inspirated
* on Mauritz Cornelis stairs's works which derivated the mode's name.
* M.C. Escher (1898-1972) was a dutch artist and many people prefer to
* say he was a mathematician.
*
* Thanks goes to Brian Paul for making it possible and inexpensive to use
* OpenGL at home.
*
* Since I'm not a native English speaker, my apologies for any grammatical
* mistake.
*
* My e-mail address is
* [email protected]
*
* Marcelo F. Vianna (Jun-01-1997)
*
* Revision History:
* 07-Jan-98: This would be a scene for the escher mode, but now escher mode
* was splitted in different modes for each scene. This is the
* initial release and is not working yet.
* Marcelo F. Vianna.
*
*/
/*-
* Texture mapping is only available on RGBA contexts, Mono and color index
* visuals DO NOT support texture mapping in OpenGL.
*
* BUT Mesa do implements RGBA contexts in pseudo color visuals, so texture
* mapping shuld work on PseudoColor, DirectColor, TrueColor using Mesa. Mono
* is not officially supported for both OpenGL and Mesa, but seems to not crash
* Mesa.
*
* In real OpenGL, PseudoColor DO NOT support texture map (as far as I know).
*/
#ifdef STANDALONE
# define DEFAULTS "*delay: 20000 \n" \
"*showFPS: False \n"
# define release_stairs 0
# include "xlockmore.h" /* from the xscreensaver distribution */
#else /* !STANDALONE */
# include "xlock.h" /* from the xlockmore distribution */
#endif /* !STANDALONE */
#ifdef USE_GL
#if 0
#include "e_textures.h"
#else
#include "ximage-loader.h"
#include "images/gen/wood_png.h"
#endif
#include "sphere.h"
#include "gltrackball.h"
ENTRYPOINT ModeSpecOpt stairs_opts =
{0, NULL, 0, NULL, NULL};
#ifdef USE_MODULES
ModStruct stairs_description =
{"stairs", "init_stairs", "draw_stairs", NULL,
"draw_stairs", "change_stairs", "free_stairs", &stairs_opts,
1000, 1, 1, 1, 4, 1.0, "",
"Shows Infinite Stairs, an Escher-like scene", 0, NULL};
#endif
#define Scale4Window 0.3
#define Scale4Iconic 0.4
#define sqr(A) ((A)*(A))
#ifndef Pi
#define Pi M_PI
#endif
/*************************************************************************/
typedef struct {
GLint WindH, WindW;
GLfloat step;
int rotating;
int AreObjectsDefined[1];
int sphere_position;
int sphere_tick;
GLXContext *glx_context;
trackball_state *trackball;
Bool button_down_p;
GLuint objects;
} stairsstruct;
static const float front_shininess[] = {60.0};
static const float front_specular[] = {0.7, 0.7, 0.7, 1.0};
static const float ambient[] = {0.0, 0.0, 0.0, 1.0};
static const float diffuse[] = {1.0, 1.0, 1.0, 1.0};
static const float position0[] = {1.0, 1.0, 1.0, 0.0};
static const float position1[] = {-1.0, -1.0, 1.0, 0.0};
static const float lmodel_ambient[] = {0.5, 0.5, 0.5, 1.0};
static const float lmodel_twoside[] = {GL_TRUE};
static const float MaterialYellow[] = {0.7, 0.7, 0.0, 1.0};
static const float MaterialWhite[] = {0.7, 0.7, 0.7, 1.0};
static const float ball_positions[] = {
-3.0, 3.0, 1.0,
-3.0, 2.8, 2.0,
-3.0, 2.6, 3.0,
-2.0, 2.4, 3.0,
-1.0, 2.2, 3.0,
0.0, 2.0, 3.0,
1.0, 1.8, 3.0,
2.0, 1.6, 3.0,
2.0, 1.5, 2.0,
2.0, 1.4, 1.0,
2.0, 1.3, 0.0,
2.0, 1.2, -1.0,
2.0, 1.1, -2.0,
1.0, 0.9, -2.0,
0.0, 0.7, -2.0,
-1.0, 0.5, -2.0,
};
#define NPOSITIONS ((sizeof ball_positions) / (sizeof ball_positions[0]) / 3)
#define SPHERE_TICKS 32
static stairsstruct *stairs = NULL;
static int
draw_block(GLfloat width, GLfloat height, GLfloat thickness)
{
int polys = 0;
glFrontFace(GL_CCW);
glBegin(GL_QUADS);
glNormal3f(0, 0, 1);
glTexCoord2f(0, 0);
glVertex3f(-width, -height, thickness);
glTexCoord2f(1, 0);
glVertex3f(width, -height, thickness);
glTexCoord2f(1, 1);
glVertex3f(width, height, thickness);
glTexCoord2f(0, 1);
glVertex3f(-width, height, thickness);
polys++;
glNormal3f(0, 0, -1);
glTexCoord2f(0, 0);
glVertex3f(-width, height, -thickness);
glTexCoord2f(1, 0);
glVertex3f(width, height, -thickness);
glTexCoord2f(1, 1);
glVertex3f(width, -height, -thickness);
glTexCoord2f(0, 1);
glVertex3f(-width, -height, -thickness);
polys++;
glNormal3f(0, 1, 0);
glTexCoord2f(0, 0);
glVertex3f(-width, height, thickness);
glTexCoord2f(1, 0);
glVertex3f(width, height, thickness);
glTexCoord2f(1, 1);
glVertex3f(width, height, -thickness);
glTexCoord2f(0, 1);
glVertex3f(-width, height, -thickness);
polys++;
glNormal3f(0, -1, 0);
glTexCoord2f(0, 0);
glVertex3f(-width, -height, -thickness);
glTexCoord2f(1, 0);
glVertex3f(width, -height, -thickness);
glTexCoord2f(1, 1);
glVertex3f(width, -height, thickness);
glTexCoord2f(0, 1);
glVertex3f(-width, -height, thickness);
polys++;
glNormal3f(1, 0, 0);
glTexCoord2f(0, 0);
glVertex3f(width, -height, thickness);
glTexCoord2f(1, 0);
glVertex3f(width, -height, -thickness);
glTexCoord2f(1, 1);
glVertex3f(width, height, -thickness);
glTexCoord2f(0, 1);
glVertex3f(width, height, thickness);
polys++;
glNormal3f(-1, 0, 0);
glTexCoord2f(0, 0);
glVertex3f(-width, height, thickness);
glTexCoord2f(1, 0);
glVertex3f(-width, height, -thickness);
glTexCoord2f(1, 1);
glVertex3f(-width, -height, -thickness);
glTexCoord2f(0, 1);
glVertex3f(-width, -height, thickness);
polys++;
glEnd();
return polys;
}
static void
draw_stairs_internal(ModeInfo * mi)
{
GLfloat X;
mi->polygon_count = 0;
glPushMatrix();
glPushMatrix();
glTranslatef(-3.0, 0.1, 2.0);
for (X = 0; X < 2; X++) {
mi->polygon_count += draw_block(0.5, 2.7 + 0.1 * X, 0.5);
glTranslatef(0.0, 0.1, -1.0);
}
glPopMatrix();
glTranslatef(-3.0, 0.0, 3.0);
glPushMatrix();
for (X = 0; X < 6; X++) {
mi->polygon_count += draw_block(0.5, 2.6 - 0.1 * X, 0.5);
glTranslatef(1.0, -0.1, 0.0);
}
glTranslatef(-1.0, -0.9, -1.0);
for (X = 0; X < 5; X++) {
mi->polygon_count += draw_block(0.5, 3.0 - 0.1 * X, 0.5);
glTranslatef(0.0, 0.0, -1.0);
}
glTranslatef(-1.0, -1.1, 1.0);
for (X = 0; X < 3; X++) {
mi->polygon_count += draw_block(0.5, 3.5 - 0.1 * X, 0.5);
glTranslatef(-1.0, -0.1, 0.0);
}
glPopMatrix();
glPopMatrix();
}
/*#define DEBUG*/
/*#define DEBUG_PATH*/
static int
draw_sphere(int pos, int tick)
{
int pos2 = (pos+1) % NPOSITIONS;
GLfloat x1 = ball_positions[pos*3];
GLfloat y1 = ball_positions[pos*3+1];
GLfloat z1 = ball_positions[pos*3+2];
GLfloat x2 = ball_positions[pos2*3];
GLfloat y2 = ball_positions[pos2*3+1];
GLfloat z2 = ball_positions[pos2*3+2];
GLfloat frac = tick / (GLfloat) SPHERE_TICKS;
GLfloat x = x1 + (x2 - x1) * frac;
GLfloat y = y1 + (y2 - y1) * frac + (2 * sin (M_PI * frac));
GLfloat z = z1 + (z2 - z1) * frac;
int polys = 0;
glPushMatrix();
# ifdef DEBUG_PATH
glVertex3f(x, y, z);
if (tick == 0) {
glVertex3f(x, y-7.5, z);
glVertex3f(x, y, z); glVertex3f(x, y, z-0.6);
glVertex3f(x, y, z); glVertex3f(x, y, z+0.6);
glVertex3f(x, y, z); glVertex3f(x+0.6, y, z);
glVertex3f(x, y, z); glVertex3f(x-0.6, y, z);
glVertex3f(x, y, z);
}
# else /* !DEBUG_PATH */
y += 0.5;
glTranslatef(x, y, z);
glScalef (0.5, 0.5, 0.5);
/* make ball a little smaller on the gap to obscure distance */
if (pos == NPOSITIONS-1)
glScalef (0.95, 0.95, 0.95);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialYellow);
glDisable (GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glFrontFace(GL_CCW);
polys += unit_sphere (32, 32, False);
glShadeModel(GL_FLAT);
glEnable (GL_TEXTURE_2D);
#endif /* !DEBUG_PATH */
glPopMatrix();
return polys;
}
ENTRYPOINT void
reshape_stairs (ModeInfo * mi, int width, int height)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
int y = 0;
if (width > height * 5) { /* tiny window: show middle */
height = width;
y = -height/2;
}
glViewport(0, y, sp->WindW = (GLint) width, sp->WindH = (GLint) height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 15.0);
glMatrixMode(GL_MODELVIEW);
if (width >= 1024) {
glLineWidth(3);
glPointSize(3);
} else if (width >= 512) {
glLineWidth(2);
glPointSize(2);
} else {
glLineWidth(1);
glPointSize(1);
}
}
ENTRYPOINT Bool
stairs_handle_event (ModeInfo *mi, XEvent *event)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
if (gltrackball_event_handler (event, sp->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&sp->button_down_p))
return True;
else if (event->xany.type == KeyPress)
{
KeySym keysym;
char c = 0;
XLookupString (&event->xkey, &c, 1, &keysym, 0);
if (c == ' ' || c == '\t')
{
gltrackball_reset (sp->trackball, 0, 0);
return True;
}
}
return False;
}
static void
pinit(ModeInfo *mi)
{
/* int status; */
glClearDepth(1.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position0);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_NORMALIZE);
glCullFace(GL_BACK);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialWhite);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#if 0
clear_gl_error();
status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3,
WoodTextureWidth, WoodTextureHeight,
GL_RGB, GL_UNSIGNED_BYTE, WoodTextureData);
if (status)
{
const char *s = (char *) gluErrorString (status);
fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n",
progname, WoodTextureWidth, WoodTextureHeight,
(s ? s : "(unknown)"));
exit (1);
}
check_gl_error("mipmapping");
#else
{
XImage *img = image_data_to_ximage (mi->dpy, mi->xgwa.visual,
wood_png, sizeof(wood_png));
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
img->width, img->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, img->data);
check_gl_error("texture");
XDestroyImage (img);
}
#endif
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular);
}
ENTRYPOINT void
init_stairs (ModeInfo * mi)
{
int screen = MI_SCREEN(mi);
stairsstruct *sp;
MI_INIT (mi, stairs);
sp = &stairs[screen];
sp->step = 0.0;
sp->rotating = 0;
sp->sphere_position = NRAND(NPOSITIONS);
sp->sphere_tick = 0;
if ((sp->glx_context = init_GL(mi)) != NULL) {
reshape_stairs(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glDrawBuffer(GL_BACK);
if (!glIsList(sp->objects))
sp->objects = glGenLists(1);
pinit(mi);
} else {
MI_CLEARWINDOW(mi);
}
sp->trackball = gltrackball_init (False);
}
ENTRYPOINT void
draw_stairs (ModeInfo * mi)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
GLfloat rot = current_device_rotation();
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!sp->glx_context)
return;
glXMakeCurrent(display, window, *sp->glx_context);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(rot, 0, 0, 1);
glTranslatef(0.0, 0.0, -10.0);
if (!MI_IS_ICONIC(mi)) {
glScalef(Scale4Window * sp->WindH / sp->WindW, Scale4Window, Scale4Window);
} else {
glScalef(Scale4Iconic * sp->WindH / sp->WindW, Scale4Iconic, Scale4Iconic);
}
# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
{
GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
if (rot != 0 && rot != 180 && rot != -180)
glScalef (1/h, 1/h, 1/h);
}
# endif
gltrackball_rotate (sp->trackball);
glTranslatef(0, 0.5, 0);
glRotatef(44.5, 1, 0, 0);
glRotatef(50, 0, 1, 0);
if (!sp->rotating) {
if ((LRAND() % 500) == 0)
sp->rotating = (LRAND() & 1) ? 1 : -1;
}
if (sp->rotating) {
glRotatef(sp->rotating * sp->step, 0, 1, 0);
if (sp->step >= 360) {
sp->rotating = 0;
sp->step = 0;
}
# ifndef DEBUG
if (!sp->button_down_p)
sp->step += 2;
# endif /* DEBUG */
}
draw_stairs_internal(mi);
# ifdef DEBUG
{
int i, j;
# ifdef DEBUG_PATH
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glBegin (GL_LINE_LOOP);
# endif /* DEBUG_PATH */
for (i = 0; i < NPOSITIONS; i ++)
for (j = 0; j < SPHERE_TICKS; j++)
mi->polygon_count += draw_sphere(i, j);
# ifdef DEBUG_PATH
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
# endif /* DEBUG_PATH */
}
#else /* !DEBUG */
mi->polygon_count += draw_sphere(sp->sphere_position, sp->sphere_tick);
#endif /* !DEBUG */
if (sp->button_down_p)
;
else if (++sp->sphere_tick >= SPHERE_TICKS)
{
sp->sphere_tick = 0;
if (++sp->sphere_position >= NPOSITIONS)
sp->sphere_position = 0;
}
glPopMatrix();
if (mi->fps_p) do_fps (mi);
glFlush();
glXSwapBuffers(display, window);
}
#ifndef STANDALONE
ENTRYPOINT void
change_stairs (ModeInfo * mi)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
if (!sp->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *sp->glx_context);
pinit();
}
#endif /* !STANDALONE */
ENTRYPOINT void
free_stairs (ModeInfo * mi)
{
stairsstruct *sp = &stairs[MI_SCREEN(mi)];
if (!sp->glx_context) return;
glXMakeCurrent (MI_DISPLAY(mi), MI_WINDOW(mi), *sp->glx_context);
if (glIsList(sp->objects)) glDeleteLists(sp->objects, 1);
if (sp->trackball) gltrackball_free (sp->trackball);
}
XSCREENSAVER_MODULE ("Stairs", stairs)
#endif
|
453904.c | /*
* Copyright (c) 2017 Wladimir J. van der Laan
* Distributed under the MIT software license, see the accompanying
* file COPYING or http://www.opensource.org/licenses/mit-license.php.
*/
#include "debugger.h"
#include "psys/psys_constants.h"
#include "psys/psys_debug.h"
#include "psys/psys_helpers.h"
#include "psys/psys_registers.h"
#include "psys/psys_state.h"
#include "util/memutil.h"
#include <stdio.h>
#include <fcntl.h>
#include <readline/history.h>
#include <readline/readline.h>
#include <unistd.h>
/** Rudimentary p-system debugger. The following functionality would be nice:
* - Load / set VM register (lpr/spr)
* - Breakpoint on data change
* - Break on runtime fault / error
* - Show static closure (static links above current stackframe)
* - Access intermediate variables (lda, lod, str) (can be done through ups/downs and locals manipulation)
* - Call procedure (with arguments) (create fake MSCW)
* - Expression evaluation (convenience)
* - Switch task
* - Change task priority
* - List tasks (nontrivial, unlike for erecs there seems to be no linked directory of tasks)
* - Create/compare execution trace
* - Make resident/swap out segment (can be done as soon as calling procedures is possible)
* - Throw runtime fault / error
* - Print heap statistics
* - Disassemble range
* - Set/clear interpreter debug flags
*/
#define MAX_BREAKPOINTS 40
#define ATITLE "\x1b[38;5;202;48;5;235m"
#define ASUBTITLE "\x1b[38;5;214m"
#define ARESET "\x1b[0m"
/** One debugger breakpoint */
struct dbg_breakpoint {
bool used;
bool active;
int num;
/* Only one type of breakpoint for now:
* by segment:offset code address.
*/
struct psys_segment_id seg; /* Segment name */
psys_word addr; /* Address relative to segment */
};
/** Description of one stack frame, with forward
* and backward links.
*/
struct dbg_stackframe {
struct psys_segment_id seg; /* Segment name */
psys_word curproc;
psys_word mp;
psys_word base;
psys_word erec;
psys_word ipc; /* Address relative to segment */
psys_word sib;
psys_word msstat;
/* Double-linked list. Stacks grow downward so "up" refers to the caller
* and "down" to the callee.
*/
struct dbg_stackframe *down, *up;
};
/** Global debugger mode */
enum debugger_mode {
DM_NONE,
DM_SINGLE_STEP, /* Single-stepping */
DM_STEP_OUT, /* Stepping out of function */
DM_STEP_OVER, /* Stepping over (next instruction in function or parent) */
};
/** Global debugger state */
struct psys_debugger {
struct psys_state *state;
/* While single-stepping this prevents stopping immediately on the same
* instruction after the interpreter thread starts.
*/
psys_word curerec;
psys_word curipc;
/* Number of breakpoint entries used */
int num_breakpoints;
/* Breakpoints */
struct dbg_breakpoint breakpoints[MAX_BREAKPOINTS];
/* Current debugger mode */
enum debugger_mode mode;
/* Currently selected task (used to filter single-stepping) */
psys_word curtask;
/* Currently selected frame pointers (used for step-out and step-over) */
psys_word target_mp1;
psys_word target_mp2;
};
/** Primitive argument parsing / splitting.
* Separates out arguments separated by any number of spaces.
*/
static unsigned parse_args(char **args, unsigned max, char *line)
{
char *arg = line;
unsigned num = 0;
if (!line)
return 0;
/* skip initial spaces */
while (*arg == ' ') {
++arg;
}
/* split arguments */
while (arg && *arg && num < max) {
char *nextarg = strchr(arg, ' ');
args[num++] = arg;
if (nextarg) { /* if separator found, move past spaces to argument */
*nextarg = '\0';
++nextarg;
while (*nextarg == ' ') {
++nextarg;
}
}
arg = nextarg;
}
return num;
}
/* Get initial erec pointer from KERNEL. From there the list of erecs can be
* traversed.
*/
static psys_fulladdr first_erec_ptr(struct psys_state *s)
{
return psys_ldw(s, 0x14e);
}
/** Assign a segment name. Names are case-insensitive, like Pascal.
* Names longer than 8 characters will be truncated.
*/
static void assign_segment_id(struct psys_segment_id *id, const char *name)
{
unsigned i;
/* Make truncated, uppercased, space-padded version of name to compare to */
for (i = 0; i < 8 && name[i]; ++i) {
id->name[i] = toupper(name[i]);
}
for (; i < 8; ++i) {
id->name[i] = ' ';
}
}
/** Get erec for segment by name. Names are case-insensitive, like Pascal.
*/
static psys_fulladdr get_erec_for_segment(struct psys_state *s, const char *name)
{
psys_word erec = first_erec_ptr(s);
struct psys_segment_id id;
assign_segment_id(&id, name);
/* Traverse linked list of erecs */
while (erec) {
psys_word sib = psys_ldw(s, erec + PSYS_EREC_Env_SIB);
if (!memcmp(id.name, psys_bytes(s, sib + PSYS_SIB_Seg_Name), 8)) {
return erec;
}
erec = psys_ldw(s, erec + PSYS_EREC_Next_Rec);
}
return PSYS_NIL;
}
/** Get globals base and size for segment by name */
static psys_fulladdr get_globals(struct psys_state *s, char *name, psys_word *data_size)
{
psys_fulladdr erec = get_erec_for_segment(s, name);
if (erec == PSYS_NIL) {
if (data_size) {
*data_size = 0;
}
return erec;
}
if (data_size) {
psys_word sib = psys_ldw(s, erec + PSYS_EREC_Env_SIB);
*data_size = psys_ldw(s, sib + PSYS_SIB_Data_Size);
}
return psys_ldw(s, erec + PSYS_EREC_Env_Data);
}
/** Get segment residency status for an erec */
static bool is_segment_resident(struct psys_state *s, psys_word erec)
{
psys_word sib = psys_ldw(s, erec + PSYS_EREC_Env_SIB);
/* seg_base will be 0 if not resident */
psys_word seg_base = psys_ldw(s, sib + PSYS_SIB_Seg_Base);
return seg_base != 0 ? true : false;
}
/** Get a free breakpoint */
static struct dbg_breakpoint *new_breakpoint(struct psys_debugger *dbg)
{
int i;
for (i = 0; i < MAX_BREAKPOINTS; ++i) {
struct dbg_breakpoint *brk = &dbg->breakpoints[i];
if (!brk->used) {
/* Adjust num_breakpoints to include the newly allocated slot */
if (i >= dbg->num_breakpoints) {
dbg->num_breakpoints = i + 1;
}
brk->used = true;
brk->num = i;
return brk;
}
}
return NULL;
}
/*** Frame handling ***/
static void stack_frame_print(struct psys_state *s, struct dbg_stackframe *frame)
{
psys_debug(" %-8.8s:0x%02x:%04x mp=0x%04x base=0x%04x erec=0x%04x\n",
frame->seg.name, frame->curproc, frame->ipc,
frame->mp, frame->base, frame->erec);
}
/** Create doubly-linked list from stack frame.
* Returns downmost frame. The result must be freed with
* stack_frames_free.
*/
static struct dbg_stackframe *get_stack_frames(struct psys_state *s)
{
psys_word mp_up;
struct dbg_stackframe *frame, *lowest;
lowest = frame = CALLOC_STRUCT(dbg_stackframe);
frame->curproc = s->curproc;
frame->ipc = s->ipc - s->curseg;
frame->mp = s->mp;
frame->base = s->base;
frame->erec = s->erec;
while (true) {
struct dbg_stackframe *frame_down;
/** Fill in sib, segment name and static link for current frame */
frame->sib = psys_ldw(s, frame->erec + PSYS_EREC_Env_SIB);
memcpy(&frame->seg, psys_bytes(s, frame->sib + PSYS_SIB_Seg_Name), 8);
frame->msstat = psys_ldw(s, frame->mp + PSYS_MSCW_MSSTAT);
/* Advance to caller frame, if there are any */
mp_up = psys_ldw(s, frame->mp + PSYS_MSCW_MSDYN);
if (mp_up == 0 || frame->mp == mp_up) {
break; /* At the top, nothing more to do */
}
/* Create and attach frame */
frame_down = frame;
frame = CALLOC_STRUCT(dbg_stackframe);
frame->down = frame_down;
frame_down->up = frame;
/* As these are stored at procedure call time, take them from caller
* frame */
frame->mp = mp_up;
frame->erec = psys_ldw(s, frame_down->mp + PSYS_MSCW_MSENV);
frame->curproc = psys_ldsw(s, frame_down->mp + PSYS_MSCW_MPROC);
frame->ipc = psys_ldw(s, frame_down->mp + PSYS_MSCW_IPC);
/* Get new base pointer from erec */
frame->base = psys_ldw(s, frame->erec + PSYS_EREC_Env_Data);
}
return lowest;
}
/** Free stack frames structure (starting at downmost frame) */
static void stack_frames_free(struct dbg_stackframe *frame)
{
struct dbg_stackframe *next;
while (frame) {
next = frame->up;
free(frame);
frame = next;
}
}
/** Get static/lexical parent of stack frame, or NULL */
static struct dbg_stackframe *stack_frame_static_parent(struct dbg_stackframe *frame)
{
psys_word msstat = frame->msstat;
while (frame && frame->mp != msstat) {
frame = frame->up;
}
return frame;
}
/** Get static/lexical child of stack frame, or NULL.
* If there are more activation records that refer to lexical children of this procedure,
* this returns the first one encountered.
*/
static struct dbg_stackframe *stack_frame_static_child(struct dbg_stackframe *frame)
{
psys_word mp = frame->mp;
while (frame && frame->msstat != mp) {
frame = frame->down;
}
return frame;
}
/** Maximum number of arguments for any debugger command.
*/
#define MAX_ARGS (10)
void psys_debugger_run(struct psys_debugger *dbg, bool user)
{
struct psys_state *s = dbg->state;
struct dbg_stackframe *frames, *frame;
char *line = NULL;
if (!user) {
psys_print_info(s);
dbg->mode = DM_NONE;
} else {
printf("** Entering psys debugger: type 'h' for help **\n");
}
frame = frames = get_stack_frames(s);
while (true) {
bool isrepeat; /* Repeat flag: could be used to continue memory dump/disassembly */
char *args[MAX_ARGS];
char *cmd;
unsigned num;
line = readline("\x1b[38;5;220mpsys\x1b[38;5;235m>\x1b[38;5;238m>\x1b[38;5;242m>\x1b[0m ");
if (!line) {
/* EOF / Ctrl-D */
exit(1);
} else if (!*line) {
/* Empty line: repeat last command */
HIST_ENTRY *h = previous_history();
if (h) {
free(line);
line = strdup(h->line);
isrepeat = true;
}
} else {
add_history(line);
isrepeat = false;
}
/* num is number of tokens, including command */
num = parse_args(args, MAX_ARGS, line);
(void)isrepeat; /* unused for now */
if (num) {
cmd = args[0];
if (!strcmp(cmd, "q")) {
exit(1);
} else if (!strcmp(cmd, "b")) { /* Set breakpoint or list breakpoints */
if (num >= 3) {
struct dbg_breakpoint *brk = new_breakpoint(dbg);
assign_segment_id(&brk->seg, args[1]);
brk->addr = strtol(args[2], NULL, 0);
brk->active = true;
printf("Set breakpoint %d at %.8s:0x%x\n", brk->num, brk->seg.name, brk->addr);
} else {
int i;
printf(ATITLE "> Breakpoints >" ARESET "\n");
for (i = 0; i < dbg->num_breakpoints; ++i) {
struct dbg_breakpoint *brk = &dbg->breakpoints[i];
if (brk->used) {
printf("%2d %d at %.8s:0x%x\n", i, brk->active, brk->seg.name, brk->addr);
}
}
}
} else if (!strcmp(cmd, "db") || !strcmp(cmd, "eb")) { /* Disable or enable breakpoint */
if (num >= 2) {
int i = strtol(args[1], NULL, 0);
bool enable = !strcmp(cmd, "eb");
if (i >= 0 && i < dbg->num_breakpoints) {
struct dbg_breakpoint *brk = &dbg->breakpoints[i];
brk->active = enable;
printf("%s breakpoint %d\n", enable ? "Enabled" : "Disabled", brk->num);
} else {
printf("Breakpoint %i out of range\n", i);
}
} else {
printf("One argument required\n");
}
} else if (!strcmp(cmd, "l")) { /* List segments */
psys_word erec = first_erec_ptr(s);
printf(ATITLE "erec sib flg segname base size " ARESET "\n");
while (erec) {
psys_word sib = psys_ldw(s, erec + PSYS_EREC_Env_SIB);
psys_word data_base = psys_ldw(s, erec + PSYS_EREC_Env_Data); /* globals start */
psys_word data_size = psys_ldw(s, sib + PSYS_SIB_Data_Size) * 2; /* globals size in bytes */
psys_word evec = psys_ldw(s, erec + PSYS_EREC_Env_Vect);
psys_word num_evec = psys_ldw(s, W(evec, 0));
unsigned i;
/* Print main segment */
printf("%04x %04x %c %-8.8s %04x %04x\n",
erec, sib,
is_segment_resident(s, erec) ? 'R' : '-',
psys_bytes(s, sib + PSYS_SIB_Seg_Name),
data_base, data_size);
/* Subsidiary segments. These will be referenced in the segment's evec
* and have the same evec pointer (and the same BASE, but that's less reliable
* as some segments have no globals).
*/
for (i = 1; i < num_evec; ++i) {
psys_word serec = psys_ldw(s, W(evec, i));
if (serec) {
psys_word ssib = psys_ldw(s, serec + PSYS_EREC_Env_SIB);
psys_word sevec = psys_ldw(s, serec + PSYS_EREC_Env_Vect);
if (serec != erec && sevec == evec) {
printf(" %04x %04x %c %-8.8s\n",
serec, ssib,
is_segment_resident(s, serec) ? 'R' : '-',
psys_bytes(s, ssib + PSYS_SIB_Seg_Name));
}
}
}
erec = psys_ldw(s, erec + PSYS_EREC_Next_Rec);
}
} else if (!strcmp(cmd, "bt")) { /* Print backtrace */
psys_print_traceback(s);
} else if (!strcmp(cmd, "s") || !strcmp(cmd, "c") || !strcmp(cmd, "so") || !strcmp(cmd, "n")) { /* Single-step or continue or step out */
dbg->curtask = s->curtask;
dbg->curerec = s->erec;
dbg->curipc = s->ipc - s->curseg;
if (!strcmp(cmd, "s")) {
dbg->mode = DM_SINGLE_STEP;
} else if (!strcmp(cmd, "so") && frame->up) {
dbg->mode = DM_STEP_OUT;
dbg->target_mp1 = frame->up->mp;
} else if (!strcmp(cmd, "n") && frames->up) {
dbg->mode = DM_STEP_OVER;
dbg->target_mp1 = frames->mp;
dbg->target_mp2 = frames->up->mp;
}
goto cleanup;
} else if (!strcmp(cmd, "dm")) { /* Dump memory */
if (num >= 2) {
int fd = open(args[1], O_CREAT | O_WRONLY, 0666);
int rv = write(fd, s->memory, s->mem_size);
(void)rv;
close(fd);
printf("Wrote memory dump to %s\n", args[1]);
} else {
printf("Two arguments required\n");
}
} else if (!strcmp(cmd, "x")) { /* Examine memory */
if (num >= 2) {
unsigned size = 0x100;
if (num >= 3) {
size = strtol(args[2], NULL, 0);
}
psys_debug_hexdump(s, strtol(args[1], NULL, 0), size);
} else {
printf("One or two arguments required\n");
}
} else if (!strcmp(cmd, "ww")) { /* write word */
if (num >= 3) {
unsigned addr = strtol(args[1], NULL, 0);
unsigned i;
for (i = 2; i < num; ++i) {
psys_stw(s, addr + (i - 2) * 2, strtol(args[i], NULL, 0));
}
} else {
printf("At least two arguments required\n");
}
} else if (!strcmp(cmd, "wb")) { /* write byte */
if (num >= 3) {
unsigned addr = strtol(args[1], NULL, 0);
unsigned i;
for (i = 2; i < num; ++i) {
psys_stb(s, addr, i - 2, strtol(args[i], NULL, 0));
}
} else {
printf("At least two arguments required\n");
}
} else if (!strcmp(cmd, "sro")) { /* Store global */
if (num >= 4) {
psys_word data_size;
psys_fulladdr data_base = get_globals(s, args[1], &data_size);
unsigned addr = strtol(args[2], NULL, 0);
if (addr < data_size) {
psys_stw(s, W(data_base + PSYS_MSCW_VAROFS, addr),
strtol(args[3], NULL, 0));
} else {
if (data_base == PSYS_NIL) {
printf("No such segment known\n");
} else {
printf("Global 0x%x out of range for segment\n", addr);
}
}
} else {
printf("At least three arguments required\n");
}
} else if (!strcmp(cmd, "ldo") || !strcmp(cmd, "lao")) { /* Load global */
if (num == 3) {
psys_word data_size;
psys_fulladdr data_base = get_globals(s, args[1], &data_size);
unsigned addr = strtol(args[2], NULL, 0);
if (addr < data_size) {
if (!strcmp(cmd, "lao")) {
psys_word address = W(data_base + PSYS_MSCW_VAROFS, addr);
printf("0x%04x\n", address);
} else {
psys_word value = psys_ldw(s, W(data_base + PSYS_MSCW_VAROFS, addr));
printf("0x%04x\n", value);
}
} else {
if (data_base == PSYS_NIL) {
printf("No such segment known\n");
} else {
printf("Global 0x%x out of range for segment\n", addr);
}
}
} else {
printf("Two arguments are required\n");
}
} else if (!strcmp(cmd, "stl")) { /* Store local */
if (num >= 3) {
unsigned addr = strtol(args[1], NULL, 0);
psys_stw(s, W(frame->mp + PSYS_MSCW_VAROFS, addr),
strtol(args[2], NULL, 0));
} else {
printf("At least two arguments required\n");
}
} else if (!strcmp(cmd, "ldl") || !strcmp(cmd, "lla")) { /* Load local */
if (num == 2) {
unsigned addr = strtol(args[1], NULL, 0);
if (!strcmp(cmd, "lao")) {
psys_word address = W(frame->mp + PSYS_MSCW_VAROFS, addr);
printf("0x%04x\n", address);
} else {
psys_word value = psys_ldw(s, W(frame->mp + PSYS_MSCW_VAROFS, addr));
printf("0x%04x\n", value);
}
} else {
printf("One argument is required\n");
}
} else if (!strcmp(cmd, "r")) { /* Print registers */
/* TODO: print all registers */
psys_print_info(s);
} else if (!strcmp(cmd, "up")) { /* Go to caller stack frame */
if (frame->up) {
frame = frame->up;
stack_frame_print(s, frame);
} else {
printf("Cannot go further up\n");
}
} else if (!strcmp(cmd, "ups")) { /* Go up static link (lexical parent) */
struct dbg_stackframe *up = stack_frame_static_parent(frame);
if (up) {
frame = up;
stack_frame_print(s, frame);
} else {
printf("No further lexical parent\n");
}
} else if (!strcmp(cmd, "down")) { /* Go to callee stack frame */
if (frame->down) {
frame = frame->down;
stack_frame_print(s, frame);
} else {
printf("Cannot go further down\n");
}
} else if (!strcmp(cmd, "downs")) { /* Go to lexical child */
struct dbg_stackframe *down = stack_frame_static_child(frame);
if (down) {
frame = down;
stack_frame_print(s, frame);
} else {
printf("No lexical children of current frame\n");
}
} else if (!strcmp(cmd, "spr")) { /* Store procedure register */
if (num == 3) {
int reg = strtol(args[1], NULL, 0);
psys_word value = strtol(args[2], NULL, 0);
psys_spr(s, reg, value);
} else {
printf("Two arguments are required\n");
}
} else if (!strcmp(cmd, "lpr")) { /* Load procedure register */
if (num == 2) {
int reg = strtol(args[1], NULL, 0);
psys_word value = psys_lpr(s, reg);
printf("0x%04x\n", value);
} else {
printf("One argument is required\n");
}
} else if (!strcmp(cmd, "h") || !strcmp(cmd, "?")) {
printf(ATITLE "> Help >" ARESET "\n");
printf(ASUBTITLE ":Breakpoints:" ARESET "\n");
printf("b List breakpoints\n");
printf("b <seg> <addr> Set breakpoint at seg:addr\n");
printf("db <i> Disable breakpoint i\n");
printf("eb <i> Enable breakpoint i\n");
printf("bt Show backtrace\n");
printf(ASUBTITLE ":Execution:" ARESET "\n");
printf("s Single-step\n");
printf("so Step out of currently selected stack frame\n");
printf("n Step to next function in current or parent stack frame\n");
printf("c Continue execution\n");
printf(ASUBTITLE ":Variables:" ARESET "\n");
printf("lao <seg> <g> Show address of global variable\n");
printf("sro <seg> <g> <val> Set global variable\n");
printf("ldo <seg> <g> Examine global variable\n");
printf("lla <l> Show address of local variable\n");
printf("stl <l> <val> Set local variable\n");
printf("ldl <l> Examine local variable\n");
printf(ASUBTITLE ":Stack frames:" ARESET "\n");
printf("up Up to caller frame\n");
printf("ups Up to lexical parent\n");
printf("down Down to callee frame\n");
printf("downs Down to lexical child\n");
printf(ASUBTITLE ":Memory:" ARESET "\n");
printf("dm <file> Write entire p-system memory to file\n");
printf("wb <addr> <val> ... Write byte(s) to address\n");
printf("ww <addr> <val> ... Write word(s) to address\n");
printf("x <addr> Examine memory\n");
printf(ASUBTITLE ":Misc:" ARESET "\n");
printf("h This information\n");
printf("l List environments\n");
printf("r Show registers and current instruction\n");
printf("lpr <r> Show register r\n");
printf("spr <r> <val> Set register r to val\n");
printf("q Quit\n");
printf("\n");
printf("All values can be specified as decimal or 0xHEX.\n");
} else {
printf("Unknown command %s. Type 'h' for help.\n", cmd);
}
}
free(line);
line = NULL;
}
cleanup:
/* Clean up state and exit */
stack_frames_free(frames);
free(line);
}
/** Called for every instruction - this should break on breakpoints */
bool psys_debugger_trace(struct psys_debugger *dbg)
{
struct psys_state *s = dbg->state;
psys_word sib = psys_ldw(s, s->erec + PSYS_EREC_Env_SIB);
const psys_byte *segname = psys_bytes(s, sib + PSYS_SIB_Seg_Name);
psys_word pc = s->ipc - s->curseg; /* PC relative to current segment */
int i;
if (!(s->erec == dbg->curerec && pc == dbg->curipc)) {
/* Make sure at least one instruction has been executed after the command was set.
*/
if (s->curtask == dbg->curtask) {
/* Make sure at least one instruction has been executed and that
* we're executing in the right task.
*/
if (dbg->mode == DM_SINGLE_STEP) {
return true;
}
if (dbg->mode == DM_STEP_OUT && s->mp == dbg->target_mp1) {
return true;
}
if (dbg->mode == DM_STEP_OVER
&& (s->mp == dbg->target_mp1 || s->mp == dbg->target_mp2)) {
return true;
}
}
for (i = 0; i < dbg->num_breakpoints; ++i) {
struct dbg_breakpoint *brk = &dbg->breakpoints[i];
if (brk->used && brk->active && pc == brk->addr && !memcmp(segname, &brk->seg, 8)) {
printf("Hit breakpoint %d at %.8s:0x%x\n", i, brk->seg.name, brk->addr);
return true;
}
}
} else {
/* Clear these, so that the breakpoint will hit here next time */
dbg->curerec = 0;
dbg->curipc = 0;
}
return false;
}
struct psys_debugger *psys_debugger_new(struct psys_state *s)
{
struct psys_debugger *dbg = CALLOC_STRUCT(psys_debugger);
dbg->state = s;
return dbg;
}
void psys_debugger_destroy(struct psys_debugger *dbg)
{
free(dbg);
}
|
532333.c | /*
* top - a top users display for Unix
*
* SYNOPSIS: For DragonFly 2.x and later
*
* DESCRIPTION:
* Originally written for BSD4.4 system by Christos Zoulas.
* Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider
* Order support hacked in from top-3.5beta6/machine/m_aix41.c
* by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/)
*
* This is the machine-dependent module for DragonFly 2.5.1
* Should work for:
* DragonFly 2.x and above
*
* LIBS: -lkvm
*
* AUTHOR: Jan Lentfer <[email protected]>
* This module has been put together from different sources and is based on the
* work of many other people, e.g. Matthew Dillon, Simon Schubert, Jordan Gordeev.
*
* $FreeBSD: src/usr.bin/top/machine.c,v 1.29.2.2 2001/07/31 20:27:05 tmm Exp $
*/
#include <sys/user.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <sys/param.h>
#include "os.h"
#include <err.h>
#include <kvm.h>
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <pwd.h>
#include <sys/errno.h>
#include <sys/sysctl.h>
#include <sys/file.h>
#include <sys/vmmeter.h>
#include <sys/resource.h>
#include <sys/rtprio.h>
/* Swap */
#include <stdlib.h>
#include <string.h>
#include <sys/conf.h>
#include <osreldate.h> /* for changes in kernel structures */
#include <sys/kinfo.h>
#include <kinfo.h>
#include "top.h"
#include "display.h"
#include "machine.h"
#include "screen.h"
#include "utils.h"
int swapmode(int *retavail, int *retfree);
static int namelength;
static int cmdlength;
static int show_fullcmd;
int n_cpus = 0;
/* get_process_info passes back a handle. This is what it looks like: */
struct handle {
struct kinfo_proc **next_proc; /* points to next valid proc pointer */
int remaining; /* number of pointers remaining */
int show_threads;
};
/* declarations for load_avg */
#include "loadavg.h"
#define PP(pp, field) ((pp)->kp_ ## field)
#define LP(pp, field) ((pp)->kp_lwp.kl_ ## field)
#define VP(pp, field) ((pp)->kp_vm_ ## field)
/* what we consider to be process size: */
#define PROCSIZE(pp) (VP((pp), map_size) / 1024)
/*
* These definitions control the format of the per-process area
*/
static char smp_header[] =
" PID %-*.*s NICE SIZE RES STATE C TIME CTIME CPU COMMAND";
#define smp_Proc_format \
"%6d %-*.*s %3d%7s %6s %8.8s %3d %6s %7s %5.2f%% %.*s"
/* process state names for the "STATE" column of the display */
/*
* the extra nulls in the string "run" are for adding a slash and the
* processor number when needed
*/
const char *state_abbrev[] = {
"", "RUN\0\0\0", "STOP", "SLEEP",
};
static kvm_t *kd;
/* values that we stash away in _init and use in later routines */
static long lastpid;
/* these are for calculating cpu state percentages */
static struct kinfo_cputime *cp_time, *cp_old;
/* these are for detailing the process states */
#define MAXPSTATES 6
int process_states[MAXPSTATES];
char *procstatenames[] = {
" running, ", " idle, ", " active, ", " stopped, ", " zombie, ",
NULL
};
/* these are for detailing the cpu states */
#define CPU_STATES 5
int *cpu_states;
int* cpu_averages;
char *cpustatenames[CPU_STATES + 1] = {
"user", "nice", "system", "interrupt", "idle", NULL
};
/* these are for detailing the memory statistics */
long memory_stats[7];
char *memorynames[] = {
"K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ", "K Free",
NULL
};
long swap_stats[7];
char *swapnames[] = {
/* 0 1 2 3 4 5 */
"K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
NULL
};
/* these are for keeping track of the proc array */
static int nproc;
static int onproc = -1;
static int pref_len;
static struct kinfo_proc *pbase;
static struct kinfo_proc **pref;
static uint64_t prev_pbase_time; /* unit: us */
static struct kinfo_proc *prev_pbase;
static int prev_pbase_alloc;
static int prev_nproc;
static int fscale;
/* these are for getting the memory statistics */
static int pageshift; /* log base 2 of the pagesize */
/* define pagetok in terms of pageshift */
#define pagetok(size) ((size) << pageshift)
/* sorting orders. first is default */
char *ordernames[] = {
"cpu", "size", "res", "time", "pri", "thr", "pid", "ctime", "pres", NULL
};
/* compare routines */
int proc_compare (struct kinfo_proc **, struct kinfo_proc **);
int compare_size (struct kinfo_proc **, struct kinfo_proc **);
int compare_res (struct kinfo_proc **, struct kinfo_proc **);
int compare_time (struct kinfo_proc **, struct kinfo_proc **);
int compare_ctime (struct kinfo_proc **, struct kinfo_proc **);
int compare_prio(struct kinfo_proc **, struct kinfo_proc **);
int compare_thr (struct kinfo_proc **, struct kinfo_proc **);
int compare_pid (struct kinfo_proc **, struct kinfo_proc **);
int compare_pres(struct kinfo_proc **, struct kinfo_proc **);
int (*proc_compares[]) (struct kinfo_proc **,struct kinfo_proc **) = {
proc_compare,
compare_size,
compare_res,
compare_time,
compare_prio,
compare_thr,
compare_pid,
compare_ctime,
compare_pres,
NULL
};
static void
cputime_percentages(int out[CPU_STATES], struct kinfo_cputime *new,
struct kinfo_cputime *old)
{
struct kinfo_cputime diffs;
uint64_t total_change, half_total;
/* initialization */
total_change = 0;
diffs.cp_user = new->cp_user - old->cp_user;
diffs.cp_nice = new->cp_nice - old->cp_nice;
diffs.cp_sys = new->cp_sys - old->cp_sys;
diffs.cp_intr = new->cp_intr - old->cp_intr;
diffs.cp_idle = new->cp_idle - old->cp_idle;
total_change = diffs.cp_user + diffs.cp_nice + diffs.cp_sys +
diffs.cp_intr + diffs.cp_idle;
old->cp_user = new->cp_user;
old->cp_nice = new->cp_nice;
old->cp_sys = new->cp_sys;
old->cp_intr = new->cp_intr;
old->cp_idle = new->cp_idle;
/* avoid divide by zero potential */
if (total_change == 0)
total_change = 1;
/* calculate percentages based on overall change, rounding up */
half_total = total_change >> 1;
out[0] = ((diffs.cp_user * 1000LL + half_total) / total_change);
out[1] = ((diffs.cp_nice * 1000LL + half_total) / total_change);
out[2] = ((diffs.cp_sys * 1000LL + half_total) / total_change);
out[3] = ((diffs.cp_intr * 1000LL + half_total) / total_change);
out[4] = ((diffs.cp_idle * 1000LL + half_total) / total_change);
}
int
machine_init(struct statics *statics)
{
int pagesize;
size_t modelen, prmlen;
struct passwd *pw;
struct timeval boottime;
if (n_cpus < 1) {
if (kinfo_get_cpus(&n_cpus))
err(1, "kinfo_get_cpus failed");
}
/* get boot time */
modelen = sizeof(boottime);
if (sysctlbyname("kern.boottime", &boottime, &modelen, NULL, 0) == -1) {
/* we have no boottime to report */
boottime.tv_sec = -1;
}
prmlen = sizeof(fscale);
if (sysctlbyname("kern.fscale", &fscale, &prmlen, NULL, 0) == -1)
err(1, "sysctl kern.fscale failed");
while ((pw = getpwent()) != NULL) {
if ((int)strlen(pw->pw_name) > namelength)
namelength = strlen(pw->pw_name);
}
if (namelength < 8)
namelength = 8;
if (namelength > 13)
namelength = 13;
if ((kd = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL)) == NULL)
return -1;
pbase = NULL;
pref = NULL;
nproc = 0;
onproc = -1;
prev_pbase = NULL;
prev_pbase_alloc = 0;
prev_pbase_time = 0;
prev_nproc = 0;
/*
* get the page size with "getpagesize" and calculate pageshift from
* it
*/
pagesize = getpagesize();
pageshift = 0;
while (pagesize > 1) {
pageshift++;
pagesize >>= 1;
}
/* we only need the amount of log(2)1024 for our conversion */
pageshift -= LOG1024;
/* fill in the statics information */
statics->procstate_names = procstatenames;
statics->cpustate_names = cpustatenames;
statics->memory_names = memorynames;
statics->boottime = boottime.tv_sec;
statics->swap_names = swapnames;
statics->order_names = ordernames;
/* we need kvm descriptor in order to show full commands */
statics->flags.fullcmds = kd != NULL;
statics->flags.threads = 1;
/* all done! */
return (0);
}
char *
format_header(char *uname_field)
{
static char Header[128];
snprintf(Header, sizeof(Header), smp_header,
namelength, namelength, uname_field);
if (screen_width <= 79)
cmdlength = 80;
else
cmdlength = screen_width;
cmdlength = cmdlength - strlen(Header) + 6;
return Header;
}
static int swappgsin = -1;
static int swappgsout = -1;
extern struct timeval timeout;
void
get_system_info(struct system_info *si)
{
size_t len;
int cpu;
if (cpu_states == NULL) {
cpu_states = malloc(sizeof(*cpu_states) * CPU_STATES * n_cpus);
if (cpu_states == NULL)
err(1, "malloc");
bzero(cpu_states, sizeof(*cpu_states) * CPU_STATES * n_cpus);
}
if (cp_time == NULL) {
cp_time = malloc(2 * n_cpus * sizeof(cp_time[0]));
if (cp_time == NULL)
err(1, "cp_time");
cp_old = cp_time + n_cpus;
len = n_cpus * sizeof(cp_old[0]);
bzero(cp_time, len);
if (sysctlbyname("kern.cputime", cp_old, &len, NULL, 0))
err(1, "kern.cputime");
}
len = n_cpus * sizeof(cp_time[0]);
bzero(cp_time, len);
if (sysctlbyname("kern.cputime", cp_time, &len, NULL, 0))
err(1, "kern.cputime");
getloadavg(si->load_avg, 3);
lastpid = 0;
/* convert cp_time counts to percentages */
int combine_cpus = (enable_ncpus == 0 && n_cpus > 1);
for (cpu = 0; cpu < n_cpus; ++cpu) {
cputime_percentages(cpu_states + cpu * CPU_STATES,
&cp_time[cpu], &cp_old[cpu]);
}
if (combine_cpus) {
if (cpu_averages == NULL) {
cpu_averages = malloc(sizeof(*cpu_averages) * CPU_STATES);
if (cpu_averages == NULL)
err(1, "cpu_averages");
}
bzero(cpu_averages, sizeof(*cpu_averages) * CPU_STATES);
for (cpu = 0; cpu < n_cpus; ++cpu) {
int j = 0;
cpu_averages[0] += *(cpu_states + ((cpu * CPU_STATES) + j++) );
cpu_averages[1] += *(cpu_states + ((cpu * CPU_STATES) + j++) );
cpu_averages[2] += *(cpu_states + ((cpu * CPU_STATES) + j++) );
cpu_averages[3] += *(cpu_states + ((cpu * CPU_STATES) + j++) );
cpu_averages[4] += *(cpu_states + ((cpu * CPU_STATES) + j++) );
}
for (int i = 0; i < CPU_STATES; ++i)
cpu_averages[i] /= n_cpus;
}
/* sum memory & swap statistics */
{
struct vmmeter vmm;
struct vmstats vms;
size_t vms_size = sizeof(vms);
size_t vmm_size = sizeof(vmm);
static unsigned int swap_delay = 0;
static int swapavail = 0;
static int swapfree = 0;
static long bufspace = 0;
if (sysctlbyname("vm.vmstats", &vms, &vms_size, NULL, 0))
err(1, "sysctlbyname: vm.vmstats");
if (sysctlbyname("vm.vmmeter", &vmm, &vmm_size, NULL, 0))
err(1, "sysctlbyname: vm.vmmeter");
if (kinfo_get_vfs_bufspace(&bufspace))
err(1, "kinfo_get_vfs_bufspace");
/* convert memory stats to Kbytes */
memory_stats[0] = pagetok(vms.v_active_count);
memory_stats[1] = pagetok(vms.v_inactive_count);
memory_stats[2] = pagetok(vms.v_wire_count);
memory_stats[3] = pagetok(vms.v_cache_count);
memory_stats[4] = bufspace / 1024;
memory_stats[5] = pagetok(vms.v_free_count);
memory_stats[6] = -1;
/* first interval */
if (swappgsin < 0) {
swap_stats[4] = 0;
swap_stats[5] = 0;
}
/* compute differences between old and new swap statistic */
else {
swap_stats[4] = pagetok(((vmm.v_swappgsin - swappgsin)));
swap_stats[5] = pagetok(((vmm.v_swappgsout - swappgsout)));
}
swappgsin = vmm.v_swappgsin;
swappgsout = vmm.v_swappgsout;
/* call CPU heavy swapmode() only for changes */
if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
swap_stats[3] = swapmode(&swapavail, &swapfree);
swap_stats[0] = swapavail;
swap_stats[1] = swapavail - swapfree;
swap_stats[2] = swapfree;
}
swap_delay = 1;
swap_stats[6] = -1;
}
/* set arrays and strings */
si->cpustates = combine_cpus == 1 ?
cpu_averages : cpu_states;
si->memory = memory_stats;
si->swap = swap_stats;
if (lastpid > 0) {
si->last_pid = lastpid;
} else {
si->last_pid = -1;
}
}
static struct handle handle;
static void
fixup_pctcpu(struct kinfo_proc *fixit, uint64_t d)
{
struct kinfo_proc *pp;
uint64_t ticks;
int i;
if (prev_nproc == 0 || d == 0)
return;
if (LP(fixit, pid) == -1) {
/* Skip kernel "idle" threads */
if (PP(fixit, stat) == SIDL)
return;
for (pp = prev_pbase, i = 0; i < prev_nproc; pp++, i++) {
if (LP(pp, pid) == -1 &&
PP(pp, ktaddr) == PP(fixit, ktaddr))
break;
}
} else {
for (pp = prev_pbase, i = 0; i < prev_nproc; pp++, i++) {
if (LP(pp, pid) == LP(fixit, pid) &&
LP(pp, tid) == LP(fixit, tid)) {
if (PP(pp, paddr) != PP(fixit, paddr)) {
/* pid/tid are reused */
pp = NULL;
}
break;
}
}
}
if (i == prev_nproc || pp == NULL)
return;
ticks = LP(fixit, iticks) - LP(pp, iticks);
ticks += LP(fixit, sticks) - LP(pp, sticks);
ticks += LP(fixit, uticks) - LP(pp, uticks);
if (ticks > d)
ticks = d;
LP(fixit, pctcpu) = (ticks * (uint64_t)fscale) / d;
}
caddr_t
get_process_info(struct system_info *si, struct process_select *sel,
int compare_index)
{
struct timespec tv;
uint64_t t, d = 0;
int i;
int total_procs;
int active_procs;
struct kinfo_proc **prefp;
struct kinfo_proc *pp;
/* these are copied out of sel for speed */
int show_idle;
int show_system;
int show_uid;
int show_threads;
char *match_command;
show_threads = sel->threads;
pbase = kvm_getprocs(kd,
KERN_PROC_ALL | (show_threads ? KERN_PROC_FLAG_LWP : 0), 0, &nproc);
if (nproc > onproc)
pref = (struct kinfo_proc **)realloc(pref, sizeof(struct kinfo_proc *)
* (onproc = nproc));
if (pref == NULL || pbase == NULL) {
(void)fprintf(stderr, "top: Out of memory.\n");
quit(23);
}
clock_gettime(CLOCK_MONOTONIC_PRECISE, &tv);
t = (tv.tv_sec * 1000000ULL) + (tv.tv_nsec / 1000ULL);
if (prev_pbase_time > 0 && t > prev_pbase_time)
d = t - prev_pbase_time;
/* get a pointer to the states summary array */
si->procstates = process_states;
/* set up flags which define what we are going to select */
show_idle = sel->idle;
show_system = sel->system;
show_uid = sel->uid != -1;
show_fullcmd = sel->fullcmd;
match_command = sel->command;
/* count up process states and get pointers to interesting procs */
total_procs = 0;
active_procs = 0;
memset((char *)process_states, 0, sizeof(process_states));
prefp = pref;
for (pp = pbase, i = 0; i < nproc; pp++, i++) {
/*
* Place pointers to each valid proc structure in pref[].
* Process slots that are actually in use have a non-zero
* status field. Processes with P_SYSTEM set are system
* processes---these get ignored unless show_sysprocs is set.
*/
if ((show_system && (LP(pp, pid) == -1)) ||
(show_system || ((PP(pp, flags) & P_SYSTEM) == 0))) {
int lpstate = LP(pp, stat);
int pstate = PP(pp, stat);
total_procs++;
if (lpstate == LSRUN)
process_states[0]++;
if (pstate >= 0 && pstate < MAXPSTATES - 1)
process_states[pstate]++;
if (match_command != NULL &&
strstr(PP(pp, comm), match_command) == NULL) {
/* Command does not match */
continue;
}
if (show_uid && PP(pp, ruid) != (uid_t)sel->uid) {
/* UID does not match */
continue;
}
if (!show_system && LP(pp, pid) == -1) {
/* Don't show system processes */
continue;
}
/* Fix up pctcpu before show_idle test */
fixup_pctcpu(pp, d);
if (!show_idle && LP(pp, pctcpu) == 0 &&
lpstate != LSRUN) {
/* Don't show idle processes */
continue;
}
*prefp++ = pp;
active_procs++;
}
}
/*
* Save kinfo_procs for later pctcpu fixup.
*/
if (prev_pbase_alloc < nproc) {
prev_pbase_alloc = nproc;
prev_pbase = realloc(prev_pbase,
prev_pbase_alloc * sizeof(struct kinfo_proc));
if (prev_pbase == NULL) {
fprintf(stderr, "top: Out of memory.\n");
quit(23);
}
}
prev_nproc = nproc;
prev_pbase_time = t;
memcpy(prev_pbase, pbase, nproc * sizeof(struct kinfo_proc));
qsort((char *)pref, active_procs, sizeof(struct kinfo_proc *),
(int (*)(const void *, const void *))proc_compares[compare_index]);
/* remember active and total counts */
si->p_total = total_procs;
si->p_active = pref_len = active_procs;
/* pass back a handle */
handle.next_proc = pref;
handle.remaining = active_procs;
handle.show_threads = show_threads;
return ((caddr_t) & handle);
}
char fmt[MAX_COLS]; /* static area where result is built */
char *
format_next_process(caddr_t xhandle, char *(*get_userid) (int))
{
struct kinfo_proc *pp;
long cputime;
long ccputime;
double pct;
struct handle *hp;
char status[16];
int state;
int xnice;
char *comm;
char cputime_fmt[10], ccputime_fmt[10];
/* find and remember the next proc structure */
hp = (struct handle *)xhandle;
pp = *(hp->next_proc++);
hp->remaining--;
/* get the process's command name */
if (show_fullcmd) {
char **comm_full = kvm_getargv(kd, pp, 0);
if (comm_full != 0)
comm = *comm_full;
else
comm = PP(pp, comm);
}
else {
comm = PP(pp, comm);
}
/* the actual field to display */
char cmdfield[MAX_COLS];
if (PP(pp, flags) & P_SYSTEM) {
/* system process */
snprintf(cmdfield, sizeof cmdfield, "[%s]", comm);
} else if (hp->show_threads && PP(pp, nthreads) > 1) {
/* display it as a thread */
if (strcmp(PP(pp, comm), LP(pp, comm)) == 0) {
snprintf(cmdfield, sizeof cmdfield, "%s{%d}", comm,
LP(pp, tid));
} else {
/* show thread name in addition to tid */
snprintf(cmdfield, sizeof cmdfield, "%s{%d/%s}", comm,
LP(pp, tid), LP(pp, comm));
}
} else {
snprintf(cmdfield, sizeof cmdfield, "%s", comm);
}
/*
* Convert the process's runtime from microseconds to seconds. This
* time includes the interrupt time to be in compliance with ps output.
*/
cputime = (LP(pp, uticks) + LP(pp, sticks) + LP(pp, iticks)) / 1000000;
ccputime = cputime + PP(pp, cru).ru_stime.tv_sec + PP(pp, cru).ru_utime.tv_sec;
format_time(cputime, cputime_fmt, sizeof(cputime_fmt));
format_time(ccputime, ccputime_fmt, sizeof(ccputime_fmt));
/* calculate the base for cpu percentages */
pct = pctdouble(LP(pp, pctcpu));
/* generate "STATE" field */
switch (state = LP(pp, stat)) {
case LSRUN:
if (LP(pp, tdflags) & TDF_RUNNING)
sprintf(status, "CPU%d", LP(pp, cpuid));
else
strcpy(status, "RUN");
break;
case LSSLEEP:
if (LP(pp, wmesg) != NULL) {
sprintf(status, "%.8s", LP(pp, wmesg)); /* WMESGLEN */
break;
}
/* fall through */
default:
if (state >= 0 && (unsigned)state < NELEM(state_abbrev))
sprintf(status, "%.6s", state_abbrev[(unsigned char)state]);
else
sprintf(status, "?%5d", state);
break;
}
if (PP(pp, stat) == SZOMB)
strcpy(status, "ZOMB");
/*
* idle time 0 - 31 -> nice value +21 - +52 normal time -> nice
* value -20 - +20 real time 0 - 31 -> nice value -52 - -21 thread
* 0 - 31 -> nice value -53 -
*/
switch (LP(pp, rtprio.type)) {
case RTP_PRIO_REALTIME:
xnice = PRIO_MIN - 1 - RTP_PRIO_MAX + LP(pp, rtprio.prio);
break;
case RTP_PRIO_IDLE:
xnice = PRIO_MAX + 1 + LP(pp, rtprio.prio);
break;
case RTP_PRIO_THREAD:
xnice = PRIO_MIN - 1 - RTP_PRIO_MAX - LP(pp, rtprio.prio);
break;
default:
xnice = PP(pp, nice);
break;
}
/* format this entry */
snprintf(fmt, sizeof(fmt),
smp_Proc_format,
(int)PP(pp, pid),
namelength, namelength,
get_userid(PP(pp, ruid)),
(int)xnice,
format_k(PROCSIZE(pp)),
format_k(pagetok(VP(pp, rssize))),
status,
LP(pp, cpuid),
cputime_fmt,
ccputime_fmt,
100.0 * pct,
cmdlength,
cmdfield);
/* return the result */
return (fmt);
}
/* comparison routines for qsort */
/*
* proc_compare - comparison function for "qsort"
* Compares the resource consumption of two processes using five
* distinct keys. The keys (in descending order of importance) are:
* percent cpu, cpu ticks, state, resident set size, total virtual
* memory usage. The process states are ordered as follows (from least
* to most important): WAIT, zombie, sleep, stop, start, run. The
* array declaration below maps a process state index into a number
* that reflects this ordering.
*/
static unsigned char sorted_state[] =
{
0, /* not used */
3, /* sleep */
1, /* ABANDONED (WAIT) */
6, /* run */
5, /* start */
2, /* zombie */
4 /* stop */
};
#define ORDERKEY_PCTCPU \
if (lresult = (long) LP(p2, pctcpu) - (long) LP(p1, pctcpu), \
(result = lresult > 0 ? 1 : lresult < 0 ? -1 : 0) == 0)
#define CPTICKS(p) (LP(p, uticks) + LP(p, sticks) + LP(p, iticks))
#define ORDERKEY_CPTICKS \
if ((result = CPTICKS(p2) > CPTICKS(p1) ? 1 : \
CPTICKS(p2) < CPTICKS(p1) ? -1 : 0) == 0)
#define CTIME(p) (((LP(p, uticks) + LP(p, sticks) + LP(p, iticks))/1000000) + \
PP(p, cru).ru_stime.tv_sec + PP(p, cru).ru_utime.tv_sec)
#define ORDERKEY_CTIME \
if ((result = CTIME(p2) > CTIME(p1) ? 1 : \
CTIME(p2) < CTIME(p1) ? -1 : 0) == 0)
#define ORDERKEY_STATE \
if ((result = sorted_state[(unsigned char) PP(p2, stat)] - \
sorted_state[(unsigned char) PP(p1, stat)]) == 0)
#define ORDERKEY_PRIO \
if ((result = LP(p2, prio) - LP(p1, prio)) == 0)
#define ORDERKEY_KTHREADS \
if ((result = (LP(p1, pid) == 0) - (LP(p2, pid) == 0)) == 0)
#define ORDERKEY_KTHREADS_PRIO \
if ((result = LP(p2, tdprio) - LP(p1, tdprio)) == 0)
#define ORDERKEY_RSSIZE \
if ((result = VP(p2, rssize) - VP(p1, rssize)) == 0)
#define ORDERKEY_MEM \
if ( (result = PROCSIZE(p2) - PROCSIZE(p1)) == 0 )
#define ORDERKEY_PID \
if ( (result = PP(p1, pid) - PP(p2, pid)) == 0)
#define ORDERKEY_PRSSIZE \
if((result = VP(p2, prssize) - VP(p1, prssize)) == 0)
static __inline int
orderkey_kernidle(const struct kinfo_proc *p1, const struct kinfo_proc *p2)
{
int p1_kidle = 0, p2_kidle = 0;
if (LP(p1, pid) == -1 && PP(p1, stat) == SIDL)
p1_kidle = 1;
if (LP(p2, pid) == -1 && PP(p2, stat) == SIDL)
p2_kidle = 1;
if (!p2_kidle && p1_kidle)
return 1;
if (p2_kidle && !p1_kidle)
return -1;
return 0;
}
#define ORDERKEY_KIDLE if ((result = orderkey_kernidle(p1, p2)) == 0)
/* compare_cpu - the comparison function for sorting by cpu percentage */
int
proc_compare(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_KIDLE
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_RSSIZE
ORDERKEY_MEM
{}
return (result);
}
/* compare_size - the comparison function for sorting by total memory usage */
int
compare_size(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_MEM
ORDERKEY_RSSIZE
ORDERKEY_KIDLE
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
{}
return (result);
}
/* compare_res - the comparison function for sorting by resident set size */
int
compare_res(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_RSSIZE
ORDERKEY_MEM
ORDERKEY_KIDLE
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
{}
return (result);
}
/* compare_pres - the comparison function for sorting by proportional resident set size */
int
compare_pres(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_PRSSIZE
ORDERKEY_RSSIZE
ORDERKEY_MEM
ORDERKEY_KIDLE
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
{}
return (result);
}
/* compare_time - the comparison function for sorting by total cpu time */
int
compare_time(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_KIDLE
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_KTHREADS
ORDERKEY_KTHREADS_PRIO
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_RSSIZE
ORDERKEY_MEM
{}
return (result);
}
int
compare_ctime(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_KIDLE
ORDERKEY_CTIME
ORDERKEY_PCTCPU
ORDERKEY_KTHREADS
ORDERKEY_KTHREADS_PRIO
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_RSSIZE
ORDERKEY_MEM
{}
return (result);
}
/* compare_prio - the comparison function for sorting by cpu percentage */
int
compare_prio(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_KTHREADS
ORDERKEY_KTHREADS_PRIO
ORDERKEY_PRIO
ORDERKEY_KIDLE
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_RSSIZE
ORDERKEY_MEM
{}
return (result);
}
int
compare_thr(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
pctcpu lresult;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **)pp1;
p2 = *(struct kinfo_proc **)pp2;
ORDERKEY_KTHREADS
ORDERKEY_KTHREADS_PRIO
ORDERKEY_KIDLE
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_RSSIZE
ORDERKEY_MEM
{}
return (result);
}
/* compare_pid - the comparison function for sorting by process id */
int
compare_pid(struct kinfo_proc **pp1, struct kinfo_proc **pp2)
{
struct kinfo_proc *p1;
struct kinfo_proc *p2;
int result;
/* remove one level of indirection */
p1 = *(struct kinfo_proc **) pp1;
p2 = *(struct kinfo_proc **) pp2;
ORDERKEY_PID
;
return(result);
}
/*
* proc_owner(pid) - returns the uid that owns process "pid", or -1 if
* the process does not exist.
* It is EXTREMLY IMPORTANT that this function work correctly.
* If top runs setuid root (as in SVR4), then this function
* is the only thing that stands in the way of a serious
* security problem. It validates requests for the "kill"
* and "renice" commands.
*/
int
proc_owner(int pid)
{
int xcnt;
struct kinfo_proc **prefp;
struct kinfo_proc *pp;
prefp = pref;
xcnt = pref_len;
while (--xcnt >= 0) {
pp = *prefp++;
if (PP(pp, pid) == (pid_t) pid) {
return ((int)PP(pp, ruid));
}
}
return (-1);
}
/*
* swapmode is based on a program called swapinfo written
* by Kevin Lahey <[email protected]>.
*/
int
swapmode(int *retavail, int *retfree)
{
int n;
int pagesize = getpagesize();
struct kvm_swap swapary[1];
*retavail = 0;
*retfree = 0;
#define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
n = kvm_getswapinfo(kd, swapary, 1, 0);
if (n < 0 || swapary[0].ksw_total == 0)
return (0);
*retavail = CONVERT(swapary[0].ksw_total);
*retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
n = (int)((double)swapary[0].ksw_used * 100.0 /
(double)swapary[0].ksw_total);
return (n);
}
|
45343.c | /******************************************************************************
* Copyright (c) 2011 Marvell International, Ltd. All Rights Reserved
*
* Marvell Confidential
******************************************************************************/
#ifndef __linux__
#include "tx_api.h"
#include "tx_ini.h" /* For TX_INITIALIZE_IN_PROGRESS */
#include "tx_thr.h" /* For _tx_thread_current_ptr and _tx_thread_system_state */
#endif
#include "dbg_context.h"
/*----------------------------------------------------------------------------*/
/* This logic actually comes from ExpressLogic and should, therefore be
a correct method of determining that we are in thread context and not
int interrupt or timer context */
int dbg_context_is_thread(void)
{
#ifdef __linux__
// In Linux, it is assumed all printing modules/apps will be executing
// this debug module from a thread.
return 1;
#else
extern TX_THREAD _tx_timer_thread;
/* We are in thread context if we are initializing or all of the following:
We are not in the system state (which indicates interrupt)
We have a valid thread pointer and
That thread pointer does not point to the timer thread
*/
return ((_tx_thread_system_state == TX_INITIALIZE_IN_PROGRESS) ||
(!_tx_thread_system_state &&
_tx_thread_current_ptr &&
(_tx_thread_current_ptr != &_tx_timer_thread)));
#endif
}
|
62405.c | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <axutil_linked_list.h>
#include <axutil_utils.h>
struct axutil_linked_list
{
/**The number of elements in this list. */
int size;
/**
* The first element in the list.
*/
entry_t *first;
/**
* The last element in the list.
*/
entry_t *last;
/**
* A count of the number of structural modifications that have been made to
* the list (that is, insertions and removals). Structural modifications
* are ones which change the list size or affect how iterations would
* behave. This field is available for use by Iterator and ListIterator,
* in order to set an error code in response
* to the next op on the iterator. This <i>fail-fast</i> behavior
* saves the user from many subtle bugs otherwise possible from concurrent
* modification during iteration.
* <p>
*
* To make lists fail-fast, increment this field by just 1 in the
* <code>add(int, Object)</code> and <code>remove(int)</code> methods.
* Otherwise, this field may be ignored.
*/
int mod_count;
};
AXIS2_EXTERN axutil_linked_list_t *AXIS2_CALL
axutil_linked_list_create(
const axutil_env_t *env)
{
axutil_linked_list_t *linked_list = NULL;
AXIS2_ENV_CHECK(env, NULL);
linked_list = AXIS2_MALLOC(env->allocator, sizeof(axutil_linked_list_t));
if(!linked_list)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
linked_list->size = 0;
linked_list->mod_count = 0;
linked_list->first = NULL;
linked_list->last = NULL;
return linked_list;
}
static entry_t *
axutil_linked_list_create_entry(
const axutil_env_t *env,
void *data)
{
entry_t *entry = (entry_t *)AXIS2_MALLOC(env->allocator, sizeof(entry_t));
if(!entry)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
return NULL;
}
entry->data = data;
entry->previous = NULL;
entry->next = NULL;
return entry;
}
static axis2_status_t
axutil_linked_list_add_last_entry(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
entry_t * e)
{
AXIS2_PARAM_CHECK(env->error, e, AXIS2_FAILURE);
linked_list->mod_count++;
if(linked_list->size == 0)
{
linked_list->first = linked_list->last = e;
}
else
{
e->previous = linked_list->last;
linked_list->last->next = e;
linked_list->last = e;
}
linked_list->size++;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN void AXIS2_CALL
axutil_linked_list_free(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
entry_t *current = NULL, *next = NULL;
current = linked_list->first;
while(current)
{
next = current->next;
AXIS2_FREE(env->allocator, current);
current = next;
}
AXIS2_FREE(env->allocator, linked_list);
linked_list = NULL;
}
AXIS2_EXTERN entry_t *AXIS2_CALL
axutil_linked_list_get_entry(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int n)
{
entry_t *e;
(void)env;
if(n < linked_list->size / 2)
{
e = linked_list->first;
/* n less than size/2, iterate from start */
while(n > 0)
{
e = e->next;
n = n - 1;
}
}
else
{
e = linked_list->last;
/* n greater than size/2, iterate from end */
while((n = n + 1) < linked_list->size)
{
e = e->previous;
}
}
return e;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axutil_linked_list_remove_entry(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
entry_t *e)
{
AXIS2_PARAM_CHECK(env->error, e, AXIS2_FAILURE);
linked_list->mod_count++;
linked_list->size--;
if(linked_list->size == 0)
{
linked_list->first = linked_list->last = NULL;
}
else
{
if(e == linked_list->first)
{
linked_list->first = e->next;
e->next->previous = NULL;
}
else if(e == linked_list->last)
{
linked_list->last = e->previous;
e->previous->next = NULL;
}
else
{
e->next->previous = e->previous;
e->previous->next = e->next;
}
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axutil_linked_list_check_bounds_inclusive(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int index)
{
if(index < 0 || index > linked_list->size)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INDEX_OUT_OF_BOUNDS, AXIS2_FAILURE);
return AXIS2_FALSE;
}
return AXIS2_TRUE;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axutil_linked_list_check_bounds_exclusive(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int index)
{
if(index < 0 || index >= linked_list->size)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INDEX_OUT_OF_BOUNDS, AXIS2_FAILURE);
return AXIS2_FALSE;
}
return AXIS2_TRUE;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_get_first(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
if(linked_list->size == 0)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_SUCH_ELEMENT, AXIS2_FAILURE);
return NULL;
}
return linked_list->first->data;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_get_last(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
if(linked_list->size == 0)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_SUCH_ELEMENT, AXIS2_FAILURE);
return NULL;
}
return linked_list->last->data;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_remove_first(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
void *r;
if(linked_list->size == 0)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_SUCH_ELEMENT, AXIS2_FAILURE);
return NULL;
}
linked_list->mod_count++;
linked_list->size--;
r = linked_list->first->data;
if(linked_list->first->next)
{
linked_list->first->next->previous = NULL;
}
else
{
linked_list->last = NULL;
}
linked_list->first = linked_list->first->next;
return r;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_remove_last(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
void *r = NULL;
if(linked_list->size == 0)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_SUCH_ELEMENT, AXIS2_FAILURE);
return NULL;
}
linked_list->mod_count++;
linked_list->size--;
r = linked_list->last->data;
if(linked_list->last->previous)
{
linked_list->last->previous->next = NULL;
}
else
{
linked_list->first = NULL;
}
linked_list->last = linked_list->last->previous;
return r;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axutil_linked_list_add_first(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FAILURE);
e = axutil_linked_list_create_entry(env, o);
linked_list->mod_count++;
if(linked_list->size == 0)
{
linked_list->first = linked_list->last = e;
}
else
{
e->next = linked_list->first;
linked_list->first->previous = e;
linked_list->first = e;
}
linked_list->size++;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axutil_linked_list_add_last(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FAILURE);
e = axutil_linked_list_create_entry(env, o);
return axutil_linked_list_add_last_entry(linked_list, env, e);
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axutil_linked_list_contains(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FALSE);
e = linked_list->first;
while(e)
{
if(o == e->data)
return AXIS2_TRUE;
e = e->next;
}
return AXIS2_FALSE;
}
AXIS2_EXTERN int AXIS2_CALL
axutil_linked_list_size(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
AXIS2_ENV_CHECK(env, -1);
AXIS2_PARAM_CHECK(env->error, linked_list, -1);
return linked_list->size;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axutil_linked_list_add(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FALSE);
e = axutil_linked_list_create_entry(env, o);
return axutil_linked_list_add_last_entry(linked_list, env, e);
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axutil_linked_list_remove(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FALSE);
e = linked_list->first;
while(e)
{
if(o == e->data)
{
return axutil_linked_list_remove_entry(linked_list, env, e);
}
e = e->next;
}
return AXIS2_FALSE;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axutil_linked_list_clear(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, linked_list, AXIS2_FAILURE);
if(linked_list->size > 0)
{
linked_list->mod_count++;
linked_list->first = NULL;
linked_list->last = NULL;
linked_list->size = 0;
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_get(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int idx)
{
axutil_linked_list_check_bounds_exclusive(linked_list, env, idx);
return axutil_linked_list_get_entry(linked_list, env, idx)->data;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_set(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int idx,
void *o)
{
entry_t *e;
void *old;
AXIS2_PARAM_CHECK(env->error, o, NULL);
axutil_linked_list_check_bounds_exclusive(linked_list, env, idx);
e = axutil_linked_list_get_entry(linked_list, env, idx);
old = e->data;
e->data = o;
return old;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axutil_linked_list_add_at_index(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int idx,
void *o)
{
entry_t *after = NULL;
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FAILURE);
axutil_linked_list_check_bounds_inclusive(linked_list, env, idx);
e = axutil_linked_list_create_entry(env, o);
if(idx < linked_list->size)
{
linked_list->mod_count++;
after = axutil_linked_list_get_entry(linked_list, env, idx);
e->next = after;
e->previous = after->previous;
if(after->previous == NULL)
linked_list->first = e;
else
after->previous->next = e;
after->previous = e;
linked_list->size++;
}
else
{
axutil_linked_list_add_last_entry(linked_list, env, e);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN void *AXIS2_CALL
axutil_linked_list_remove_at_index(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
int idx)
{
entry_t *e;
axutil_linked_list_check_bounds_exclusive(linked_list, env, idx);
e = axutil_linked_list_get_entry(linked_list, env, idx);
axutil_linked_list_remove_entry(linked_list, env, e);
return e->data;
}
AXIS2_EXTERN int AXIS2_CALL
axutil_linked_list_index_of(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
int idx = 0;
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FAILURE);
e = linked_list->first;
while(e)
{
if(o == e->data)
return idx;
idx++;
e = e->next;
}
return -1;
}
AXIS2_EXTERN int AXIS2_CALL
axutil_linked_list_last_index_of(
axutil_linked_list_t *linked_list,
const axutil_env_t *env,
void *o)
{
int idx;
entry_t *e;
AXIS2_PARAM_CHECK(env->error, o, AXIS2_FAILURE);
idx = linked_list->size - 1;
e = linked_list->last;
while(e)
{
if(o == e->data)
return idx;
idx--;
e = e->previous;
}
return -1;
}
AXIS2_EXTERN void **AXIS2_CALL
axutil_linked_list_to_array(
axutil_linked_list_t *linked_list,
const axutil_env_t *env)
{
int i = 0;
void **array;
entry_t *e;
array = (void **)AXIS2_MALLOC(env->allocator, (size_t)linked_list->size * sizeof(void *));
e = linked_list->first;
for(i = 0; i < linked_list->size; i++)
{
array[i] = e->data;
e = e->next;
}
return array;
}
|
515475.c | char buttonimagejpg[] = {
0xFF,0xD8,0xFF,0xE1,0x00,0xDD,0x45,0x78,0x69,0x66,0x00,0x00,0x49,0x49,0x2A,
0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x12,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,
0x00,0x00,0x00,0x1A,0x01,0x05,0x00,0x01,0x00,0x00,0x00,0x6E,0x00,0x00,0x00,0x1B,
0x01,0x05,0x00,0x01,0x00,0x00,0x00,0x76,0x00,0x00,0x00,0x28,0x01,0x03,0x00,0x01,
0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x31,0x01,0x02,0x00,0x15,0x00,0x00,0x00,0x7E,
0x00,0x00,0x00,0x32,0x01,0x02,0x00,0x14,0x00,0x00,0x00,0x93,0x00,0x00,0x00,0x13,
0x02,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x69,0x87,0x04,0x00,0x01,
0x00,0x00,0x00,0xA7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2C,0x01,0x00,0x00,0x01,
0x00,0x00,0x00,0x2C,0x01,0x00,0x00,0x01,0x00,0x00,0x00,0x41,0x43,0x44,0x53,0x65,
0x65,0x20,0x53,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x20,0x32,0x30,0x31,0x38,0x00,
0x32,0x30,0x31,0x39,0x3A,0x31,0x31,0x3A,0x31,0x35,0x20,0x31,0x37,0x3A,0x33,0x33,
0x3A,0x34,0x33,0x00,0x03,0x00,0x90,0x92,0x02,0x00,0x04,0x00,0x00,0x00,0x36,0x38,
0x36,0x00,0x02,0xA0,0x04,0x00,0x01,0x00,0x00,0x00,0xFE,0x02,0x00,0x00,0x03,0xA0,
0x04,0x00,0x01,0x00,0x00,0x00,0x4D,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x65,0x00,
0x00,0x00,0xFF,0xC0,0x00,0x11,0x08,0x01,0x4D,0x02,0xFE,0x03,0x01,0x21,0x00,0x02,
0x11,0x01,0x03,0x11,0x01,0xFF,0xDB,0x00,0x84,0x00,0x02,0x01,0x01,0x01,0x01,0x01,
0x02,0x01,0x01,0x01,0x02,0x02,0x02,0x02,0x03,0x05,0x03,0x03,0x02,0x02,0x03,0x06,
0x04,0x04,0x03,0x05,0x07,0x06,0x07,0x07,0x07,0x06,0x07,0x06,0x08,0x09,0x0B,0x09,
0x08,0x08,0x0A,0x08,0x06,0x07,0x0A,0x0D,0x0A,0x0A,0x0B,0x0C,0x0C,0x0D,0x0C,0x07,
0x09,0x0E,0x0F,0x0E,0x0C,0x0F,0x0B,0x0C,0x0C,0x0C,0x01,0x03,0x03,0x03,0x04,0x03,
0x04,0x08,0x04,0x04,0x08,0x12,0x0C,0x0A,0x0C,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0xFF,0xC4,0x00,0x9D,0x00,
0x01,0x00,0x01,0x04,0x03,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x08,0x01,0x06,0x07,0x09,0x02,0x04,0x05,0x0A,0x03,0x10,0x00,0x01,0x03,0x03,
0x03,0x03,0x02,0x03,0x05,0x03,0x05,0x0A,0x05,0x0F,0x0D,0x00,0x00,0x01,0x02,0x03,
0x04,0x05,0x06,0x07,0x08,0x11,0x09,0x12,0x21,0x13,0x31,0x0A,0x22,0x41,0x14,0x15,
0x32,0x51,0x71,0x16,0x23,0x61,0x1A,0x42,0x52,0x81,0xD4,0x17,0x24,0x25,0x58,0x59,
0x62,0x72,0x91,0x95,0x96,0x18,0x76,0xB1,0xB4,0xB5,0x19,0x27,0x33,0x34,0x35,0x36,
0x38,0x39,0x43,0x53,0x74,0x83,0x92,0xA1,0xB2,0x26,0x2A,0x44,0x45,0x47,0x55,0x56,
0x73,0x82,0x84,0x93,0xA3,0xD1,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xDA,0x00,0x0C,0x03,0x01,
0x00,0x02,0x11,0x03,0x11,0x00,0x3F,0x00,0xDF,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x28,0x8A,0x9F,0x99,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xAB,0xC1,0x82,0x7A,0x82,0xF5,0x0A,0xDB,0x77,0x4D,0xAD,0xBE,0xDC,0x37,0x0B,0xB9,
0x2C,0xB3,0xEC,0x74,0x30,0x2A,0xC1,0x6F,0xB3,0xD2,0x2B,0x5F,0x5F,0x7B,0xAA,0x54,
0xE5,0x94,0xB4,0xD1,0x2A,0xA7,0x7C,0x8B,0xC7,0x2A,0xAB,0xC3,0x58,0xDE,0x5C,0xE5,
0x44,0x4E,0x40,0xD2,0xAE,0xD0,0x3E,0x2D,0x4D,0xCD,0x59,0xB7,0x73,0x2E,0xA3,0x6F,
0xC3,0x4A,0x66,0xB6,0x6D,0xFF,0x00,0x52,0xEA,0x5D,0x15,0x87,0xEE,0xAB,0x63,0xD3,
0xF6,0x5E,0x38,0x1F,0xE9,0x3A,0x6A,0x7A,0x8E,0xD4,0x5B,0x83,0x1A,0xAA,0x89,0x52,
0x9C,0xAB,0xBB,0x97,0xBA,0x34,0x6F,0x1E,0x93,0xBE,0x80,0xB4,0xEF,0x51,0x70,0x7D,
0x56,0xC2,0xAD,0x5A,0x8F,0xA6,0xB9,0x65,0x05,0xF6,0xC3,0x7C,0xA5,0x8E,0xB6,0xDF,
0x78,0xB5,0xCE,0xD9,0xA9,0xAB,0x20,0x7B,0x7B,0x99,0x24,0x6F,0x6F,0x87,0x35,0x51,
0x7D,0xD0,0x0F,0x79,0x3D,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x8A,0xA8,
0x80,0x47,0x2E,0xA6,0x5D,0x4E,0x36,0xD9,0xD2,0xE7,0x6F,0xB5,0x3A,0xE1,0xAF,0x97,
0xD5,0x96,0xB2,0xA7,0xBE,0x0B,0x0E,0x23,0x41,0x23,0x7E,0xF0,0xC8,0x6A,0x91,0xBC,
0xA4,0x30,0xB5,0x7F,0x0B,0x13,0x94,0x59,0x25,0x72,0x76,0xC6,0xD5,0xE5,0x79,0x55,
0x6B,0x5D,0xA2,0x6C,0x0B,0x46,0xF5,0x73,0xAC,0xE6,0x77,0x79,0xEB,0x33,0xD6,0xC3,
0x53,0x9D,0xA7,0x3B,0x5F,0xC2,0xBB,0xFE,0xEC,0xB3,0xB2,0x69,0x20,0x65,0xCA,0x16,
0xBF,0xE5,0xB6,0xDA,0xE2,0xFC,0x6A,0xC7,0xBD,0x11,0xB2,0x4E,0xD4,0x59,0x66,0x93,
0x96,0xB3,0x97,0x79,0x88,0x2E,0x5B,0x5F,0x5B,0x9E,0x9B,0x3D,0x4F,0x32,0x3B,0xA7,
0x4D,0x5D,0xED,0xED,0x72,0xC7,0xA5,0x9B,0x77,0x9D,0x62,0xB7,0x69,0x7E,0x61,0x64,
0x62,0x53,0xDC,0x30,0x09,0xA3,0x6F,0xA5,0x0C,0xF5,0x0F,0x4E,0x63,0x89,0xB2,0x78,
0x55,0x58,0xD3,0xD3,0x8F,0x9E,0xC9,0x52,0x56,0x2B,0xA4,0x6F,0xEB,0xB5,0xFD,0xD2,
0xEF,0x6B,0xE1,0x6B,0xDD,0x3D,0x3E,0xD3,0xF7,0x7A,0xDA,0xBC,0xFB,0x6D,0x19,0x9D,
0x53,0xAB,0x6C,0xD9,0x1D,0x99,0xAE,0x96,0x9D,0x21,0x7B,0x93,0x9A,0xFB,0x72,0xAA,
0xAA,0x32,0x44,0x47,0x35,0xD3,0xD1,0xAB,0xB8,0x5E,0x7B,0x9A,0xBF,0x33,0x64,0x78,
0x7D,0x09,0xE8,0xDE,0xB2,0xE9,0x7E,0xBF,0xE9,0x9D,0x93,0x59,0x34,0x63,0x38,0xB7,
0xE4,0xB8,0xBE,0x47,0x4A,0xDA,0xCB,0x6D,0xF2,0xD5,0x2F,0xA9,0x05,0x5C,0x4E,0xFA,
0xA2,0xFB,0xA2,0xA2,0xA2,0xA3,0x9A,0xBC,0x39,0xAE,0x45,0x6B,0x91,0x15,0x15,0x0B,
0xA5,0x15,0x15,0x00,0xA8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0xFB,0x11,0x37,0xAB,
0x37,0x57,0x3D,0xB8,0xF4,0x9F,0xD0,0xA7,0xEA,0x2E,0xAA,0xD7,0x36,0xEF,0x96,0x5D,
0x99,0x24,0x78,0xD6,0x05,0x45,0x3A,0x32,0xB2,0xF7,0x33,0x7D,0xD5,0x57,0x85,0xF4,
0xA9,0xD8,0xAA,0x8B,0x24,0xCA,0x9C,0x35,0x3C,0x22,0x39,0xEA,0xD6,0xA8,0x69,0x43,
0x48,0x36,0xFD,0x94,0xF5,0x01,0xBA,0xDD,0xBA,0xF1,0xFC,0x40,0xDA,0x93,0x3E,0x3B,
0xA1,0xF6,0xE5,0x47,0x63,0x58,0x47,0x2F,0x86,0x5C,0xA5,0xA8,0xE7,0x3A,0x9E,0xDD,
0x6F,0xA5,0xE7,0xBD,0x94,0x4A,0xA8,0xA8,0x9D,0xAB,0xDF,0x3A,0xA3,0x9C,0xAE,0x46,
0xF7,0xCC,0x90,0x8F,0xAB,0x5F,0x57,0x9D,0x63,0xEA,0x7F,0xA9,0x94,0x34,0x4E,0xB3,
0xC5,0x85,0x69,0x3E,0x1C,0x9F,0x65,0xC3,0xB4,0xBA,0xCE,0xA9,0x1D,0x0D,0xA2,0x9D,
0xAD,0xEC,0x64,0x92,0x35,0x88,0x8C,0x7D,0x42,0xB1,0x11,0xAA,0xE4,0x44,0x6B,0x1B,
0xF2,0x31,0x1A,0xDE,0x7B,0x82,0x20,0x22,0x9B,0x37,0xE9,0x67,0xD5,0xCB,0x45,0x72,
0xDD,0x0F,0xFF,0x00,0xA9,0x3D,0xD5,0xF2,0xD7,0x2E,0x5F,0xA0,0x57,0xB7,0x36,0x1B,
0x16,0x5F,0x50,0xE7,0x3E,0xE5,0xA7,0x95,0x1E,0x52,0x29,0x62,0x9B,0x87,0x3D,0x29,
0xD8,0xAE,0xF0,0xA8,0x8A,0xE8,0x91,0x5C,0x88,0x8F,0x89,0x5D,0x18,0x19,0xFF,0x00,
0x4B,0x35,0x8B,0x7A,0x3F,0x0A,0xD6,0xE7,0xA8,0xB1,0x3C,0xBA,0xE5,0x51,0xAB,0x7B,
0x4A,0xD4,0xEA,0x96,0xD6,0xDA,0xAF,0xB6,0x79,0x12,0x4A,0x5A,0xD8,0x5E,0x88,0xE4,
0xAB,0xA4,0x7A,0x2A,0xC7,0x05,0x7B,0x62,0x56,0xAB,0xE1,0xEE,0xF4,0xEA,0x18,0x88,
0xA8,0xAA,0x9D,0xB2,0x33,0xE8,0x23,0x6D,0x7B,0x95,0xD1,0x4D,0xDA,0xE8,0xD5,0x8B,
0x5F,0x36,0xF7,0xA8,0x34,0x59,0x36,0x29,0x91,0x53,0xFA,0xF4,0x57,0x5A,0x17,0xF8,
0x77,0xF4,0x98,0xF6,0xAF,0xCD,0x1C,0x8C,0x77,0x2D,0x7C,0x6E,0x44,0x73,0x5C,0x8A,
0x8A,0x80,0x5F,0xC8,0xA0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3A,0xD7,0x66,0xD7,0x3E,
0x82,0x66,0x5B,0x2A,0x22,0x8A,0xA1,0x63,0x77,0xA5,0x24,0xEC,0x57,0xB1,0xAE,0xE3,
0xE5,0x57,0x35,0x15,0x15,0x53,0x9E,0x39,0x44,0x54,0x55,0x4F,0xAA,0x7B,0x9A,0x36,
0xC4,0x3A,0x11,0xEE,0x3B,0x33,0xDD,0xAE,0xAE,0x75,0x3D,0xEB,0xA9,0x9C,0xD0,0xEA,
0x65,0x9B,0x4F,0x23,0xAC,0xBC,0xDA,0x31,0x1C,0x76,0xA7,0xBE,0x97,0x27,0xA6,0xA3,
0x85,0xF5,0x31,0x22,0x42,0xEE,0x12,0x9A,0x85,0x8C,0x6F,0x6B,0x29,0x1D,0xC2,0xBE,
0x4E,0xEF,0x51,0x7B,0x7B,0x96,0x50,0xD3,0xCF,0x54,0xEE,0xAB,0x5B,0x84,0xEA,0x97,
0xAD,0x8D,0xCF,0x75,0x3A,0x48,0xEC,0x78,0x95,0x91,0xAB,0x4D,0x8B,0xE9,0xED,0xAA,
0x45,0xFB,0xBB,0x1E,0xA5,0xE1,0x11,0x1A,0xC6,0xA2,0x22,0x3E,0x67,0x35,0xAD,0xEF,
0x95,0x51,0x15,0xDC,0x22,0x22,0x35,0x8D,0x6B,0x12,0x2E,0x22,0x72,0xBC,0x73,0xC0,
0x0E,0xDF,0x3C,0x72,0x9F,0xAF,0x23,0xCB,0x57,0xC2,0x81,0xB4,0x9E,0x83,0xFD,0x44,
0xAA,0x35,0x4E,0xE7,0x69,0xE8,0xAB,0xBD,0x9D,0x3E,0x66,0xA9,0x68,0x6E,0xAD,0xD6,
0xB6,0xCF,0x6D,0xB6,0xDC,0xE5,0x5F,0xB5,0xE2,0x35,0xB2,0xF2,0xB1,0x4F,0x49,0x32,
0xFC,0xCC,0x8D,0x24,0xF9,0xBB,0x5A,0xA8,0xB1,0xB9,0x7D,0x48,0xD5,0x17,0xBD,0xB2,
0x6C,0xEB,0xA4,0x47,0x45,0xFE,0xA2,0x7D,0x28,0xFA,0x88,0x65,0x96,0x0D,0x35,0xDC,
0x45,0xAA,0xE9,0xB5,0xBB,0xB4,0x2F,0xAD,0x92,0x8A,0xF5,0x22,0xCB,0x59,0x74,0x95,
0xC8,0xAD,0x82,0x34,0xA5,0x6A,0xA2,0x53,0xD6,0xC3,0xC3,0x52,0x4A,0x94,0xFD,0xDC,
0x91,0xA3,0x53,0xB5,0xCA,0xE4,0x6C,0x41,0xB7,0x58,0x9A,0xE6,0xB7,0xE6,0x77,0x2A,
0x73,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0A,0x2B,0x51,0xDE,0xE6,0x21,0xDF,0xFC,0x6D,
0x6E,0xC4,0x75,0xAF,0x84,0x4F,0xFB,0xC2,0xBE,0xFF,0x00,0xD1,0xD3,0x81,0xF0,0xC9,
0x27,0xE2,0xFE,0xA4,0xFF,0x00,0x90,0xCF,0x3D,0x2B,0xE9,0xE9,0xEA,0xFA,0x99,0x6D,
0xEE,0x96,0xAA,0x08,0xE5,0x8A,0x4D,0x47,0xC7,0xD8,0xF8,0xA5,0x6A,0x39,0xAF,0x45,
0xB8,0xC1,0xCA,0x2A,0x2F,0x85,0x45,0xFC,0x94,0x0F,0xAD,0x6E,0xAF,0x7A,0x7F,0x81,
0xDB,0xBA,0x57,0xEE,0x2E,0xBA,0x87,0x0C,0xB4,0x45,0x34,0x3A,0x73,0x7D,0x7B,0x25,
0x8E,0x8A,0x26,0xB9,0x8A,0x94,0x33,0x70,0xA8,0xA8,0xDE,0x51,0x7F,0x89,0xF1,0x5C,
0xA0,0x4A,0xFE,0x86,0x3F,0xF8,0xDE,0xF6,0xEF,0xFF,0x00,0x1E,0x28,0x3F,0xF8,0xD4,
0xFB,0x49,0x85,0x8D,0xED,0x47,0x70,0x9C,0x81,0xFA,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x18,0x87,0xA8,0x1A,0xA2,0x6C,0x3F,0x5A,0xD5,0xCA,0x88,0x89,0x81,0x5F,0xBC,
0xAA,0xF0,0x89,0xFE,0x0E,0x9C,0x0F,0x86,0x47,0xC6,0xBC,0xFE,0x26,0xFB,0x27,0xF3,
0x90,0xCF,0x7D,0x2A,0x93,0xB3,0xA9,0xC6,0xDE,0x15,0xCF,0x6A,0x7F,0xD7,0x27,0x1E,
0xFE,0x72,0x7F,0xF7,0x94,0x00,0x7D,0x75,0x75,0x86,0x54,0x5E,0x94,0xBB,0x8F,0xF9,
0xB8,0xFF,0x00,0xAD,0xC5,0xFB,0xCA,0xFD,0x3F,0xBC,0x66,0x3E,0x26,0x56,0x35,0x4F,
0xAB,0x7F,0xF6,0x90,0x09,0x5B,0xD0,0xCD,0x11,0xBD,0x5E,0xB6,0xEE,0xAE,0x7B,0x53,
0xFF,0x00,0x96,0xF4,0x1F,0xCE,0x4F,0xE9,0xA9,0xF6,0x93,0x4E,0xA8,0xAC,0x4F,0xD0,
0x0F,0xD0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0xE5,0x02,0xB9,0xA9,0xE5,0x57,0xFF,0x00,
0x78,0x1D,0x7A,0xEB,0x9D,0x15,0xBA,0x96,0x4A,0xEA,0xEA,0x96,0x43,0x04,0x4D,0x57,
0xBE,0x79,0x9D,0xD8,0xC6,0x27,0xE6,0xAE,0x5F,0x08,0x9F,0xAA,0x91,0x7B,0x72,0xFD,
0x67,0x3A,0x51,0xED,0xB2,0x8A,0xBA,0xC9,0xAE,0x9B,0xD5,0xD3,0xEF,0x55,0x23,0x7C,
0x75,0x36,0x1B,0x55,0x62,0x5E,0xAA,0x9C,0x8A,0x8A,0x8E,0x8D,0xF4,0xD4,0xAD,0x95,
0xDE,0x78,0x54,0xE1,0xC8,0x89,0xF4,0x50,0x35,0xB9,0xB8,0x5F,0x8A,0x8B,0xA3,0xFE,
0x05,0x24,0xD6,0xED,0xBB,0x6C,0x0A,0xAB,0x50,0x6A,0x62,0xE7,0xB6,0xAE,0xE3,0x60,
0xB7,0x59,0x28,0x64,0xFE,0x28,0xE7,0xB2,0x49,0xB8,0xE3,0xCF,0x98,0x9A,0xBF,0xA1,
0xB7,0xBD,0x1C,0xD3,0x4D,0xB0,0xEA,0x06,0x11,0x8C,0x6B,0x4E,0x9E,0xE8,0xC6,0x1D,
0x15,0x35,0xEA,0x86,0x92,0xF5,0x6C,0xB8,0x52,0xD9,0x69,0x58,0xF6,0xB2,0x58,0xD9,
0x34,0x52,0x35,0xED,0x67,0x28,0xBC,0x39,0xAA,0x8A,0x8B,0xEE,0x06,0x48,0xBB,0xD9,
0xAD,0x57,0xEB,0x55,0x4D,0x8E,0xF7,0x6D,0xA7,0xAC,0xA3,0xAB,0x8D,0xD1,0x4F,0x49,
0x57,0x13,0x64,0x8A,0x66,0x39,0x38,0x56,0xB9,0x8E,0x45,0x47,0x22,0xA7,0xBA,0x2A,
0x70,0xA6,0xBF,0x7A,0xDD,0xEF,0x3B,0x6D,0x1D,0x20,0xF6,0xD5,0x8F,0xEB,0x7D,0xBB,
0x67,0x5A,0x73,0x98,0xDE,0x32,0x1C,0x8E,0x1B,0x2D,0x2E,0x35,0x5B,0x6F,0xA6,0xA4,
0xF5,0x62,0xF4,0x65,0x9A,0x79,0x52,0x46,0xC2,0xE5,0x4E,0xC6,0xC6,0xD4,0xE7,0xB5,
0x53,0x99,0x5B,0xCA,0x79,0x02,0x31,0xED,0x4F,0xE2,0x9E,0xE8,0xD3,0x97,0x5D,0xE8,
0x6A,0xF5,0x87,0x6A,0x55,0xFA,0x41,0x7B,0x82,0x46,0xC8,0xCB,0xA4,0x58,0xDD,0x1D,
0xD2,0x8E,0x99,0xFF,0x00,0xD2,0x6D,0x4D,0x2B,0x12,0x74,0x54,0xFC,0xFD,0x14,0x36,
0x69,0xB6,0xEE,0xA5,0xBB,0x06,0xDD,0xD4,0x71,0x37,0x6D,0xFB,0xB7,0xC0,0xB2,0xAA,
0x99,0xB8,0xED,0xB5,0xD0,0xDD,0xA3,0x8E,0xBD,0x39,0xFE,0x95,0x24,0x8A,0xC9,0x9B,
0xFA,0x2B,0x00,0xCE,0x49,0x23,0x55,0x13,0x95,0xE3,0x9F,0xA2,0xF8,0x2B,0xCA,0x7E,
0x60,0x54,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x53,0x94,
0x1C,0xA0,0x0E,0xE6,0xF3,0xC7,0x77,0x9F,0xD4,0x72,0x9F,0x98,0x0E,0x50,0xA8,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xE2,0xF7,0xA3,0x00,0xE0,0x93,0x2F,0xD6,0x37,0xFF,0x00,0xA9,0x4E,0x4B,0x2F,0x0D,
0xE7,0x87,0x7E,0x88,0x05,0x1B,0x32,0x2A,0xF1,0xC3,0x93,0xF5,0xF0,0x1D,0x2F,0x0B,
0xC7,0x6A,0xFF,0x00,0xA8,0x0E,0x4D,0x7F,0x29,0xCF,0x94,0xFD,0x4E,0x0F,0x9B,0xB5,
0x78,0x46,0xB9,0x7F,0x44,0x55,0x03,0x97,0xA9,0xF2,0xF3,0xE7,0xF4,0x38,0xFA,0xFF,
0x00,0xE6,0xBB,0xFD,0x40,0x3D,0x7F,0xC9,0xAE,0x5F,0xE2,0x88,0xA5,0x89,0xBA,0x0D,
0xC7,0xE0,0x5B,0x49,0xDB,0xDE,0x61,0xB9,0x7D,0x50,0xA5,0xB9,0xCF,0x8F,0x61,0x36,
0xC9,0xAE,0xD7,0x08,0xAC,0xF0,0x24,0xD5,0x2F,0x86,0x34,0xE5,0xC9,0x1B,0x15,0x5A,
0x8A,0xEF,0xC9,0x15,0xC8,0x9F,0x9A,0xA0,0x1E,0x8E,0x84,0x6B,0x3E,0x27,0xB8,0x7D,
0x15,0xC4,0x75,0xEB,0x03,0xA7,0xAF,0x8A,0xC7,0x9A,0x59,0xA9,0x2F,0x96,0xF6,0x5C,
0xE1,0xF4,0x6A,0x12,0x0A,0x98,0x5B,0x34,0x69,0x23,0x39,0x54,0x6B,0xFB,0x5E,0x9C,
0xA2,0x2A,0xF0,0xBF,0x55,0x2E,0xBF,0x5B,0xCF,0x1D,0xAE,0xFD,0x51,0x17,0xFF,0x00,
0xF0,0x0A,0xFA,0x9C,0xB7,0xB9,0x39,0x5F,0xD3,0xEA,0x51,0xB2,0xF7,0x2F,0x08,0xD7,
0x7E,0xBC,0x01,0xFA,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0A,0x72,0x85,0x1C,0xF6,
0x35,0x3E,0x67,0x22,0x7E,0xAA,0x07,0x95,0x97,0xE7,0x38,0x7E,0x01,0x65,0x9B,0x26,
0xCE,0xB2,0x9B,0x75,0x96,0xDB,0x4E,0x9C,0xCB,0x70,0xBB,0xD5,0x32,0x96,0x08,0xD3,
0xDF,0x95,0x92,0x45,0x46,0xA7,0xB7,0xD5,0x48,0x7B,0xB8,0xAF,0x88,0x7F,0xA3,0xFE,
0xDA,0x7E,0xD1,0x45,0x95,0xEF,0x43,0x1D,0xBF,0xDC,0x69,0xD5,0x5B,0xF7,0x5E,0x06,
0xD9,0x6F,0xB2,0xB9,0xC9,0xCF,0x2D,0xEF,0xA7,0x6B,0xA2,0x45,0xE5,0x3F,0x9D,0x22,
0x01,0x03,0xB7,0x17,0xF1,0xB0,0x6D,0xFE,0xC2,0xB5,0x14,0x1B,0x59,0xD9,0xCE,0x57,
0x92,0xC8,0x8B,0xDB,0x15,0xCF,0x37,0xB9,0xC3,0x69,0x83,0xFD,0x2F,0x46,0x14,0x9D,
0xEE,0x4F,0xE0,0xAE,0x6A,0x91,0x2A,0xFF,0x00,0xF1,0x20,0x75,0xFD,0xDF,0xB5,0xDA,
0x6C,0x4F,0x66,0xFA,0x56,0x96,0x66,0xCE,0xEF,0x4D,0xB4,0xDA,0x4D,0x86,0xCD,0x75,
0xAA,0x62,0x2A,0xA2,0x70,0xEA,0x89,0xDB,0x51,0xDA,0xBC,0xFF,0x00,0x39,0x11,0x80,
0x75,0xA9,0xBA,0x1D,0xFC,0x49,0x9D,0x47,0x6A,0xE3,0xBB,0xEE,0xB7,0x38,0xC8,0x6D,
0x96,0xEA,0xB7,0x23,0xBD,0x4D,0x61,0xCD,0x1E,0xB1,0xC6,0xD5,0xE3,0x9E,0x28,0x21,
0x74,0xCF,0x67,0x85,0xFC,0x3E,0x93,0x7D,0xB8,0xF0,0x49,0xCD,0xBA,0xFC,0x12,0x78,
0x8D,0x32,0x43,0x72,0xDD,0x66,0xF7,0x2E,0x15,0xAA,0xBC,0x2C,0xB6,0x8D,0x3D,0xB3,
0xB2,0x99,0xA9,0xF9,0xA2,0x55,0xD4,0xAB,0xD5,0x53,0xF8,0xFA,0x29,0xFD,0x40,0x4E,
0xFD,0xBD,0xFC,0x33,0x1D,0x1D,0x36,0xF6,0xD8,0xAA,0xA2,0xDA,0xBC,0x19,0xAD,0xC2,
0x2E,0x39,0xB8,0xEA,0x2D,0xC2,0x6B,0xAA,0xC9,0xC7,0x3E,0xF0,0x2A,0xB6,0x9F,0xFF,
0x00,0xEA,0x27,0x6E,0x2D,0x8C,0x63,0xD8,0x5E,0x3B,0x41,0x88,0xE2,0x36,0x2A,0x2B,
0x5D,0xAA,0xD7,0x4E,0xCA,0x4A,0x3B,0x65,0xBA,0x16,0xC3,0x4F,0x49,0x0B,0x1A,0x8D,
0x64,0x71,0xC6,0xD4,0x46,0xB1,0x8D,0x6A,0x22,0x23,0x51,0x38,0x44,0x44,0x44,0x03,
0xD0,0x2D,0x2D,0x60,0xD0,0x9D,0x16,0xD7,0xFC,0x59,0xD8,0x46,0xB9,0x69,0x26,0x33,
0x98,0xD9,0xDF,0xCA,0xAD,0xAF,0x28,0xB6,0x43,0x5F,0x07,0x2A,0x9C,0x2A,0xA3,0x25,
0x6B,0x91,0x17,0x8F,0xAA,0x79,0x02,0x06,0x6E,0x5B,0xE1,0x59,0xE9,0x03,0xB8,0x4F,
0xB4,0x5C,0x31,0xDD,0x18,0xBB,0xE9,0xAD,0xCE,0xA1,0x17,0xFB,0xFF,0x00,0x4E,0xEE,
0xD2,0x53,0x46,0x8E,0xF3,0xC2,0xFD,0x96,0x64,0x96,0x04,0x4E,0x57,0xD9,0xAC,0x6F,
0xB1,0xAF,0xAD,0xC9,0x7C,0x14,0x5A,0xCD,0x60,0x9A,0x7B,0xEE,0xD0,0x77,0x9B,0x62,
0xBD,0xA4,0x7F,0xBC,0x82,0xD3,0x9E,0xDB,0xE5,0xB6,0xCE,0xCE,0x17,0x94,0x44,0xAB,
0xA7,0xF5,0x5A,0xE7,0x7B,0x79,0xF4,0xD8,0x9F,0xA0,0x18,0x45,0x9A,0x1D,0xF1,0x59,
0x74,0xA1,0x45,0x97,0x07,0xA9,0xD5,0xDA,0xEC,0x72,0xDC,0xA8,0xE6,0x26,0x3B,0x5A,
0xCC,0xC6,0xCE,0x91,0xB7,0x8F,0x3F,0x65,0x5F,0x5F,0xD3,0x67,0x09,0xF5,0x8D,0x8B,
0xFA,0x19,0x17,0x41,0x7E,0x32,0x9D,0xF3,0x69,0x05,0xD5,0xB8,0x7E,0xF1,0x36,0xAD,
0x89,0xE5,0xEE,0xA3,0x7A,0x45,0x53,0x25,0xB3,0xED,0x18,0xED,0xD1,0xAB,0xE3,0x95,
0x7B,0x1C,0x92,0xC5,0xDD,0xEF,0xE1,0x22,0x67,0x90,0x27,0xF6,0xDA,0x3E,0x2E,0xFE,
0x95,0x1A,0xCE,0x94,0xF6,0xDD,0x5C,0xAD,0xCC,0xF4,0xAE,0xE3,0x2F,0xCA,0xFF,0x00,
0xDA,0x8B,0x5B,0xAB,0x28,0x91,0xDF,0xC2,0xA2,0x91,0x64,0x5E,0x3F,0x8B,0xE3,0x69,
0x3F,0xB6,0xFF,0x00,0xBD,0x7D,0xA4,0x6E,0xAE,0xDA,0xDB,0xA6,0xDB,0xB7,0x27,0x84,
0xE6,0xEC,0x73,0x7B,0x96,0x2C,0x6E,0xF3,0x05,0x54,0xD1,0xA7,0xF9,0xF0,0xB5,0xDE,
0xA3,0x17,0xC7,0xB3,0x9A,0x80,0x64,0xF6,0xC8,0xD7,0x7D,0x55,0x17,0xF2,0x5F,0x0A,
0x72,0xE5,0x3F,0x30,0x2A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x9C,0xF7,
0xCB,0x4D,0x2D,0xCA,0x9E,0xCF,0x53,0x74,0xA7,0x8E,0xAE,0xA9,0x1C,0xB0,0xD3,0x49,
0x2B,0x5B,0x24,0xA8,0xD4,0xE5,0xCA,0xD6,0xAA,0xF2,0xEE,0x3E,0xBC,0x14,0xAF,0xBE,
0xDA,0x6D,0x95,0x30,0x52,0x57,0xDC,0xA0,0x82,0x5A,0xA7,0xF6,0x43,0x1C,0xD2,0xB5,
0x8E,0x99,0xDC,0x73,0xC3,0x51,0x57,0xE6,0x5F,0xE0,0x9C,0x81,0x1B,0xF5,0x2F,0xA9,
0x8E,0x9A,0x69,0x9F,0x51,0xCC,0x1F,0xA7,0x9D,0xCF,0x1B,0xF5,0x2B,0xB3,0x2C,0x6A,
0xB7,0x22,0x76,0x59,0xF7,0xAC,0x11,0xD2,0xDB,0x7E,0xCC,0xE9,0x1A,0xB4,0xF2,0x44,
0xBF,0x37,0x7B,0xBD,0x25,0xFE,0x72,0x71,0xDC,0x9E,0x17,0xCF,0x1E,0xD6,0xE7,0x6E,
0x7B,0xD8,0xAF,0xD6,0xED,0x13,0xAC,0xDA,0x7E,0x7D,0xA6,0x94,0x7A,0x7F,0x53,0x79,
0x95,0xD9,0xDC,0x19,0x5B,0x9C,0xFA,0xFB,0x95,0x07,0x11,0x2B,0x1B,0x6E,0x56,0xF2,
0x8B,0x27,0x6F,0xAD,0xF5,0x4F,0x2B,0x1A,0xF3,0xDA,0x8E,0x45,0x0C,0x0B,0x60,0xDD,
0x06,0xBF,0x55,0xFC,0x47,0x37,0x9D,0xA3,0xD4,0xEA,0x85,0xC5,0xDA,0x6F,0x4F,0xA2,
0x2C,0xC8,0xA3,0xC4,0x78,0x67,0xD9,0x5B,0x70,0xFB,0xCA,0x18,0xFE,0xD3,0xF8,0x7B,
0xBB,0xFB,0x1E,0xE6,0xF3,0xDD,0xC7,0x0B,0xEC,0x67,0x7D,0xAC,0x5D,0xF7,0xAB,0x6D,
0xD4,0xCD,0x67,0xAF,0xDE,0x2E,0xA1,0xE9,0x95,0x56,0x19,0x4F,0x91,0xF1,0x82,0xB3,
0x10,0x7B,0xA3,0xA9,0xB7,0x5B,0x39,0x93,0xE4,0xB8,0x39,0xFC,0x22,0x4D,0xDA,0xB0,
0x27,0x1C,0xAA,0xF7,0x24,0x8B,0xCF,0x0A,0xD4,0x40,0xF2,0x3A,0x6C,0x75,0x2E,0xD3,
0x6E,0xA3,0x5A,0x33,0x72,0xD5,0xFC,0x73,0x1A,0x5C,0x51,0xF4,0x19,0x1D,0xC3,0x1F,
0x4B,0x1D,0xD2,0xE9,0x05,0x45,0x44,0xFF,0x00,0x64,0x56,0xA2,0xCE,0xDE,0xDE,0x3E,
0x57,0x23,0xB9,0xE3,0x8F,0x1D,0xAB,0xE5,0x53,0xC9,0x24,0x6D,0x77,0xCB,0x5D,0xEA,
0x81,0x97,0x4B,0x45,0xC6,0x1A,0xAA,0x69,0x11,0x55,0x95,0x14,0xD2,0x36,0x46,0x3F,
0x85,0xE1,0x78,0x73,0x79,0x45,0xF2,0x8B,0xEC,0xA0,0x52,0x8A,0xF9,0x6A,0xB8,0x54,
0xD4,0x51,0xD0,0xDC,0xA9,0xE6,0x96,0x95,0xC8,0xC9,0xA2,0x8A,0x56,0xB9,0xD1,0x39,
0x53,0x94,0x47,0x22,0x2F,0x2D,0x5E,0x3E,0x8B,0xC1,0xDD,0x4F,0x60,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0xEC,0x40,0x6F,
0x88,0x73,0x70,0x7A,0xCB,0xA0,0x9B,0x2C,0xC6,0xA2,0xD2,0xBD,0x52,0xBA,0x69,0xFD,
0xAF,0x35,0xCF,0xAC,0xB8,0xB6,0x57,0xA8,0xF6,0x59,0x3D,0x2A,0x9C,0x5A,0xCB,0x55,
0x23,0xD2,0xA6,0xAD,0x92,0xFF,0x00,0xE4,0x57,0xE5,0x63,0x3D,0x4F,0xA7,0x72,0xA2,
0x2A,0x2B,0x91,0x40,0x84,0xFB,0xCD,0xD8,0x6E,0xD4,0x74,0xBF,0x7E,0xDB,0x54,0xD0,
0x6D,0xA3,0xEE,0xCB,0x55,0xEF,0x90,0xEA,0xC5,0xF6,0xA6,0x97,0x2D,0xC4,0xAC,0x7A,
0xA7,0x70,0xAD,0x9E,0xAA,0xDC,0xD8,0x1B,0x27,0xDF,0x1E,0xBC,0x72,0xB9,0xF0,0xAB,
0x7E,0x77,0x2A,0xF2,0x8C,0x91,0x19,0xF2,0xA3,0x7B,0x5C,0xA5,0xED,0xD5,0x3B,0x7C,
0xFA,0x21,0x9A,0xF5,0x51,0x8B,0xA7,0xF6,0xF1,0xF7,0x81,0x9A,0xE9,0x26,0x82,0xE9,
0xBE,0x1F,0x4D,0x76,0xBC,0xD1,0xE1,0x32,0x5C,0x19,0x5F,0x9A,0xDD,0xEA,0x92,0x37,
0x43,0x4B,0x51,0x53,0x47,0x14,0x93,0x36,0x9E,0x38,0x24,0x6B,0xD5,0x3C,0x23,0x9C,
0xD7,0xF2,0xBD,0xCE,0x6A,0xB4,0x3A,0xBD,0x32,0x77,0x67,0xA2,0x1A,0x67,0xD5,0xDB,
0x1E,0xDA,0x9F,0x4E,0x4D,0xD6,0x67,0xDA,0x9D,0xA0,0x1A,0x93,0x8B,0x57,0xD5,0x57,
0xE3,0x59,0xA7,0xDE,0xB5,0x6C,0xC3,0x2E,0xF4,0x91,0xC9,0x33,0x1F,0x4F,0x51,0x5D,
0x13,0x64,0x64,0x72,0xC7,0x12,0x35,0x5B,0xCA,0xA2,0xAC,0x8B,0xDC,0xAA,0xA8,0xCE,
0x3B,0xFB,0x7D,0xDB,0x46,0xB3,0xF5,0x19,0xEA,0xA3,0xBC,0xFD,0x0D,0xD5,0x7D,0xE4,
0x6A,0x35,0x8B,0x46,0xF0,0x9C,0xC2,0x86,0x6A,0xBC,0x13,0x11,0xBC,0x4F,0x43,0x51,
0x79,0x9E,0x6A,0x57,0xB6,0x18,0x96,0xB1,0x15,0x5D,0x05,0x1C,0x6D,0x86,0x47,0x3A,
0x08,0xBB,0x52,0x47,0xBD,0x8A,0xBF,0x81,0x00,0xCA,0xBD,0x26,0x2E,0xBA,0x91,0xB2,
0xDE,0xA1,0x7B,0xA2,0xE9,0x97,0x91,0x6B,0xA6,0x51,0x9C,0x69,0xAE,0x9A,0xDA,0xAD,
0x59,0x86,0x29,0x51,0x98,0x56,0xBE,0xBA,0xE1,0x66,0xA6,0xAA,0x85,0x24,0x9E,0x97,
0xD7,0x77,0x97,0x31,0x3D,0x46,0x22,0x27,0xB7,0x31,0xF7,0x22,0x22,0xB9,0xC4,0x23,
0xDB,0xD6,0xF7,0xBA,0x6B,0x75,0x0E,0xB6,0x64,0xFB,0xAA,0xEA,0xD5,0xD4,0x37,0x55,
0x6C,0x79,0xA6,0x45,0x7A,0xAC,0x6E,0x33,0xA7,0x98,0x5D,0x5D,0xFA,0x82,0xDB,0x81,
0xDB,0x23,0x91,0x59,0x4B,0xE8,0x25,0x0D,0x3B,0xA1,0x92,0xA1,0x5B,0xF3,0xBA,0x47,
0x2B,0xF9,0xF9,0x7B,0x93,0xBB,0xB8,0x09,0x37,0xD3,0xD3,0x79,0x9A,0xE5,0xAE,0x3D,
0x13,0x37,0x6F,0x65,0xCA,0xB5,0xC7,0x23,0xCD,0x1F,0xA4,0x54,0xF9,0x45,0x87,0x11,
0xD5,0x7B,0x8B,0x2A,0x68,0xEE,0x57,0xCB,0x53,0x2D,0xCF,0x96,0x8A,0xA9,0xF2,0x3D,
0xAC,0x97,0xD7,0x6A,0x39,0x7E,0x75,0xE1,0xE8,0x9D,0x9C,0xAF,0x29,0xCA,0xDC,0x5D,
0x13,0x7A,0x76,0x67,0x7A,0xFF,0x00,0xA0,0x1A,0x0F,0xD4,0xA3,0x77,0x1B,0xCC,0xD5,
0x4C,0x9B,0x39,0xA1,0xB5,0xD1,0xD5,0x63,0xB6,0x2B,0x65,0xFE,0x4A,0x7B,0x2D,0xBA,
0xD7,0x0C,0x6B,0x0C,0x34,0x93,0xD3,0xAB,0x5C,0xB5,0x2F,0x95,0xAD,0x59,0x27,0x91,
0xCE,0x47,0x3D,0xEF,0xE3,0x95,0xE1,0x55,0xC1,0x8E,0x37,0xA9,0xA5,0x9D,0x1B,0xF4,
0xFE,0xFF,0x00,0x9A,0xD9,0xB7,0x71,0xD6,0xAF,0x54,0x2E,0x9A,0xDE,0x8F,0xAA,0x7B,
0x2F,0x90,0xE7,0x55,0xB2,0x4F,0x8C,0xD6,0x2F,0x72,0xC5,0x14,0x56,0xEB,0x73,0x1D,
0x05,0x3B,0x62,0x55,0x63,0x56,0x27,0x37,0x94,0x44,0x5F,0xC3,0xCF,0x8B,0x7B,0x2B,
0xBA,0x65,0x7D,0x4D,0x7E,0x15,0x5A,0x7D,0xD1,0xEE,0x5F,0x55,0x33,0x4A,0x9C,0xCF,
0x4F,0xF1,0xDB,0xEC,0xDF,0x79,0x5A,0xAF,0x52,0xD2,0x36,0xFD,0x25,0x25,0x44,0x94,
0xB1,0xAD,0xC2,0x36,0xF8,0xAA,0x6A,0xC7,0x1C,0x6A,0xE4,0x7F,0x95,0x72,0x2B,0xB9,
0xE5,0xCB,0xC8,0x65,0xCD,0xAF,0xE9,0xA6,0x07,0xD2,0x37,0xA2,0xA5,0x57,0x53,0xAD,
0x2F,0xCE,0x75,0x13,0x23,0xCA,0xAB,0x34,0x82,0xD9,0x59,0x1D,0x83,0x33,0xC9,0xA7,
0xB9,0x59,0x69,0x2B,0x2A,0x22,0xA7,0x58,0x7D,0x1A,0x37,0x70,0xC8,0xA3,0x6D,0x44,
0xCC,0xF0,0xDF,0x29,0x1A,0x2B,0x51,0x53,0x95,0x53,0xBF,0xB6,0xDE,0x87,0x15,0x7B,
0xAA,0xDA,0x1E,0x31,0xB9,0xCD,0xCE,0x6F,0xAF,0x5D,0xEA,0x75,0xEB,0x50,0x6C,0x14,
0xF9,0x0A,0xE7,0x96,0xAC,0xC2,0xA6,0x96,0x0C,0x76,0xAE,0xAE,0x26,0xCF,0x0C,0x74,
0xD4,0x51,0xF6,0xC6,0x90,0xC5,0xDF,0x1B,0x5C,0xCF,0x1C,0xF6,0xBB,0xB7,0xB3,0x96,
0xF6,0x85,0xA3,0xA6,0x9B,0xEA,0xDC,0xD6,0xE3,0xBE,0x1A,0x1D,0x7B,0xCE,0xB5,0x97,
0x51,0x2A,0xDF,0xAA,0x3A,0x5D,0x4D,0x7C,0xC3,0x6E,0x39,0x75,0xAA,0x77,0xD3,0x55,
0x55,0xCF,0x44,0xF8,0x7B,0x2A,0x55,0xEC,0xED,0x54,0x95,0x62,0x99,0xAD,0x73,0xDB,
0xC2,0xB9,0x5A,0xAE,0x5F,0x2E,0x53,0x31,0x74,0x85,0xE9,0xB7,0x99,0xE4,0xF8,0x76,
0x8C,0xF5,0x38,0xDD,0x36,0xEF,0x35,0x37,0x30,0xD5,0x3B,0x9E,0x3B,0x4D,0x73,0x82,
0xD5,0x4F,0x7E,0x7C,0x38,0xE5,0x1D,0xBA,0xA6,0xDE,0x91,0x53,0xD0,0x2D,0x0A,0xB5,
0x7D,0x44,0x64,0x2F,0x63,0xDE,0xF7,0x3B,0x97,0xCE,0x8A,0xF5,0xE5,0x7C,0xA8,0x6C,
0x9E,0x36,0xF6,0x37,0x8E,0x79,0x39,0x00,0x00,0x00,0x00,0x05,0x39,0x4F,0xCC,0xE2,
0xE9,0x5A,0xD5,0xE3,0x9F,0x3F,0x92,0x01,0x68,0xEA,0xC6,0xE0,0x34,0x3F,0x41,0x6C,
0x8B,0x92,0xEB,0x86,0xB0,0xE2,0xF8,0x75,0xBD,0xAD,0x57,0x2D,0x6E,0x51,0x75,0x82,
0x82,0x2E,0x13,0x9F,0x67,0x4A,0xE6,0xF3,0xED,0xF4,0x21,0x1E,0xE2,0x3E,0x28,0x4E,
0x8E,0x9A,0x07,0xEB,0x51,0x51,0xEE,0x3A,0xA7,0x3D,0xB8,0x43,0xCF,0x34,0x1A,0x77,
0x6B,0x9A,0xE0,0x8E,0xFD,0x2A,0x5E,0x91,0xD3,0xAF,0xEA,0x92,0x28,0x10,0x3B,0x70,
0xDF,0x1B,0x63,0x11,0x25,0xB7,0x6D,0x4B,0x63,0xEE,0x55,0xF2,0xB1,0x5E,0x35,0x1A,
0xF5,0xC7,0xE5,0xC7,0x75,0x25,0x2A,0x7E,0xBE,0x3D,0x72,0x39,0xBB,0xAB,0xFF,0x00,
0xC4,0xE3,0xD4,0xAA,0x45,0xB7,0x6D,0x9B,0x14,0xCC,0xED,0xD6,0x8A,0xDF,0x08,0xBA,
0x4B,0x88,0x2D,0x1D,0x2C,0x68,0xBC,0x27,0x9B,0x94,0xAC,0x7B,0xD9,0xEE,0x9E,0x7D,
0x74,0xFC,0xFC,0x01,0xE8,0x62,0x3F,0x0C,0x3F,0x5C,0xDD,0xED,0x5E,0xE0,0xCD,0x37,
0x99,0xAC,0x76,0xFB,0x0B,0xE6,0x5F,0x56,0x4A,0x9D,0x4D,0xCB,0x67,0xBE,0x5C,0x19,
0xCF,0x9F,0x96,0x28,0x56,0x64,0x45,0x4E,0x57,0xC2,0xC8,0xDF,0xEA,0x26,0x1E,0xDD,
0x7E,0x0A,0x5D,0xAB,0xE2,0xE9,0x4F,0x71,0xDC,0xF6,0xEC,0xF3,0x4C,0xC2,0x66,0x7C,
0xD2,0x5B,0xF1,0x3A,0x38,0x2C,0xB4,0xAE,0x5F,0xE8,0xAB,0xDF,0xEB,0xC8,0xA9,0xFC,
0x51,0x58,0xA0,0x4E,0xED,0xBB,0xF4,0x05,0xE9,0x17,0xB6,0x45,0x82,0xAF,0x00,0xD9,
0x26,0x23,0x72,0xAF,0xA7,0xF2,0x97,0x4C,0xCD,0x92,0x5F,0x6A,0x3B,0xBF,0xA4,0x8B,
0x56,0xE9,0x1A,0xD5,0xF3,0xFC,0xD6,0xA1,0x2E,0x31,0xCC,0x5B,0x1E,0xC4,0xED,0x10,
0xD8,0x31,0x7B,0x1D,0x1D,0xB6,0x86,0x9D,0x3B,0x62,0xA2,0xB7,0xC2,0xD8,0x21,0x8D,
0x3F,0x24,0x63,0x11,0x1A,0x89,0xFD,0x40,0x77,0xD2,0x18,0xDB,0xF8,0x5A,0x89,0xFA,
0x21,0x54,0x44,0x4F,0x60,0x2A,0x00,0x00,0x05,0x15,0x88,0xA0,0x71,0xF4,0x59,0xEE,
0x8D,0x44,0x5F,0xCD,0x3D,0xCC,0x6D,0xAF,0x9B,0x3B,0xDA,0xBE,0xE9,0x2D,0x8E,0xB3,
0xEE,0x37,0x6E,0xD8,0x4E,0x6F,0x03,0x9B,0xDA,0x9F,0xB5,0x16,0x78,0x2B,0x24,0x8D,
0x3F,0xCD,0x91,0xED,0x57,0xB5,0x7C,0x27,0x96,0xB9,0x14,0x08,0x07,0xB9,0x4F,0x84,
0x6F,0xA4,0xFE,0xB6,0x25,0x45,0xC7,0x4B,0x6C,0x59,0x76,0x95,0xDC,0x65,0xF9,0x9A,
0xFC,0x42,0xEE,0xEA,0x9A,0x4E,0xEF,0xE3,0x4D,0x56,0x92,0xA7,0x1F,0xC1,0x8E,0x61,
0x00,0x37,0x03,0xF0,0x64,0x6F,0x3B,0x4B,0xAE,0x2F,0xCB,0x36,0x7F,0xBB,0x2C,0x53,
0x2D,0x7D,0x23,0x96,0x5A,0x7A,0x7B,0xDC,0x73,0xE3,0xF7,0x26,0xAF,0xD1,0x19,0x2B,
0x16,0x68,0x95,0xDF,0xC5,0x5E,0xC4,0x03,0x19,0xFF,0x00,0x74,0x9F,0x8A,0xDF,0xA5,
0x02,0x76,0xE4,0x91,0x6B,0x05,0x76,0x37,0x6E,0x55,0x47,0x2D,0xDE,0x9D,0x99,0xA5,
0x99,0x23,0x4E,0x7C,0x7A,0xE8,0x95,0x09,0x13,0x38,0x45,0x5F,0x0F,0x62,0x99,0x9B,
0x6E,0x3F,0x1A,0xB6,0xBD,0xE2,0xF3,0xC5,0x60,0xDD,0xF6,0xCE,0x71,0xEC,0x83,0xD2,
0x5F,0x4A,0x7B,0x9E,0x11,0x5F,0x35,0xA6,0xA5,0x8A,0x8B,0xC2,0xAA,0xD3,0x4E,0x93,
0x31,0xCE,0xFE,0x08,0xE6,0x27,0x8F,0xA0,0x1B,0x04,0xDB,0x47,0xC5,0x65,0xD2,0x1B,
0x5F,0x52,0x9E,0xDD,0x96,0xEA,0xC5,0xF7,0x4C,0xAE,0x73,0xA2,0x27,0xD8,0xB5,0x06,
0xD5,0x24,0x50,0xA3,0xBC,0x72,0x9F,0x6A,0xA7,0xF5,0x61,0x44,0xF3,0xEE,0xF7,0x37,
0xD8,0x9E,0x7A,0x3B,0xB8,0xDD,0x04,0xDC,0x3D,0x81,0x32,0x9D,0x03,0xD6,0x9C,0x53,
0x35,0xB7,0x39,0xA8,0xFF,0x00,0xB6,0xE2,0x97,0x68,0x2B,0xE3,0x44,0x5E,0x3D,0xD6,
0x27,0x3B,0x8F,0x74,0xF0,0xBC,0x01,0x79,0xB2,0x46,0xBB,0xC7,0x3E,0x7F,0x2E,0x4E,
0x5C,0xA0,0x15,0x00,0x00,0x00,0x00,0x00,0x1F,0x40,0x35,0x99,0xBF,0xA4,0x4F,0xE5,
0x1C,0x6C,0x65,0x55,0xA9,0xFF,0x00,0x70,0xF2,0xEE,0x15,0x7F,0xF4,0x19,0xBD,0x8E,
0xF7,0x5A,0xA4,0x63,0xBA,0x83,0xF4,0xF9,0xE5,0x11,0x57,0xFB,0xAA,0x54,0x7B,0xFF,
0x00,0xF9,0x34,0xE0,0x47,0x7D,0xE1,0xF4,0xBB,0xD8,0x5E,0xA0,0xFC,0x47,0x9A,0x5F,
0xA5,0x59,0x8E,0xDB,0xEC,0xF5,0xB6,0x0D,0x50,0xC1,0xEF,0x99,0x7E,0x51,0x6D,0x75,
0x4D,0x53,0x23,0xBB,0xDD,0x56,0x6A,0xB7,0xAD,0x53,0xD5,0xB2,0xA3,0x9A,0xF5,0x73,
0x51,0x55,0x18,0xAD,0x6F,0x3C,0xF8,0x32,0xE7,0x54,0x7D,0x21,0xD3,0x8D,0x01,0xDE,
0xF7,0x4D,0x1D,0x15,0xD2,0x0C,0x56,0x0B,0x1E,0x2F,0x8C,0x67,0x75,0xD6,0xEB,0x65,
0xA2,0x95,0xCF,0x74,0x74,0x90,0x32,0x0A,0x34,0x6B,0x11,0x5E,0xAA,0xE5,0xE1,0x3E,
0xAE,0x55,0x55,0xFA,0xA8,0x1E,0xB6,0x24,0x9F,0xFC,0xEC,0x1B,0xEA,0x27,0xF8,0xBB,
0x47,0xFF,0x00,0x4A,0xD3,0x96,0xCF,0x4B,0xAD,0xBD,0x68,0xD6,0xEB,0x37,0x13,0xD4,
0x77,0x6F,0xFB,0x82,0xC1,0x29,0x72,0x6C,0x3F,0x22,0xD6,0x16,0xC7,0x71,0xB1,0xD6,
0xBE,0x46,0x45,0x52,0x91,0xC9,0x34,0xCC,0xE5,0xD1,0xB9,0xAF,0x45,0x6C,0x91,0x31,
0xC8,0xA8,0xA8,0xBC,0xB5,0x00,0xB0,0x3E,0x18,0xEE,0x9B,0x3B,0x20,0xCB,0xF6,0xF7,
0x5F,0xBB,0x5C,0x93,0x6F,0x16,0x8A,0xDD,0x42,0xC5,0xB5,0x0B,0x20,0xB5,0xDB,0x32,
0x29,0xE6,0xA9,0x74,0x94,0xB4,0xB1,0xA3,0x61,0x6C,0x49,0x17,0xA9,0xE9,0x39,0x12,
0x39,0xA4,0x6F,0xCC,0xC5,0x5E,0x1D,0xEF,0xCF,0x92,0xFC,0xE8,0xF9,0xAB,0xF6,0x0E,
0x98,0x75,0x3B,0xBC,0xE9,0xDB,0xAD,0x37,0x75,0xA5,0xB0,0xED,0xCA,0xE7,0x5B,0x9F,
0x63,0xAF,0xAA,0x5E,0xD7,0x4D,0x8C,0x55,0xC4,0xEA,0xA6,0xA3,0x15,0x79,0x45,0xEC,
0x56,0xB3,0x9E,0x3F,0x9F,0x52,0xA9,0xEE,0x06,0x59,0xF8,0x71,0x74,0x5F,0x2F,0xB6,
0xEC,0xAA,0xF3,0xBD,0x1D,0x5E,0xA6,0x5F,0xDB,0xBD,0xCA,0xE4,0xF5,0xDA,0x85,0x75,
0x92,0x65,0x55,0x7B,0x29,0xE7,0x95,0xCD,0xA3,0x89,0x15,0x7F,0x99,0xE9,0x23,0xA4,
0x6F,0xE4,0x95,0x06,0xC2,0xD3,0xD8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0A,0x2F,0xB1,0xAC,0xDF,0x89,0x26,0x1B,0xEE,0x69,
0x83,0x6D,0xE7,0x44,0xB4,0xCA,0x8A,0xDB,0x93,0xE7,0xF9,0x1E,0xAA,0x50,0x54,0xD8,
0x34,0xAB,0x23,0xA3,0x5A,0x8B,0x26,0x67,0xF6,0x68,0xDD,0xEB,0xC3,0x71,0xF9,0xD8,
0x8D,0xA4,0x89,0xB3,0x32,0x47,0xAA,0xAA,0xA7,0x94,0x4E,0xDF,0xE7,0x34,0x30,0xE5,
0x93,0x2C,0xD6,0x8E,0x86,0x11,0xD3,0xEE,0x8F,0x5B,0x3A,0x3F,0x6D,0xBB,0x17,0xC1,
0x6E,0xB7,0x3A,0x6B,0x36,0x41,0x9C,0x68,0x35,0xEE,0x57,0x5E,0x2D,0x11,0x55,0x4A,
0x8C,0x6B,0x92,0x3A,0xB8,0x91,0xEF,0x8B,0xBF,0x8F,0xDD,0x46,0xF6,0xB5,0x7C,0x27,
0xCB,0xEE,0x99,0xDB,0x77,0xDB,0x64,0xDE,0xD6,0xD7,0x7A,0x9B,0x47,0xD5,0x7F,0x61,
0xBA,0x1B,0x43,0xAC,0x16,0xCC,0xD3,0x13,0x87,0x13,0xCE,0xF4,0xCF,0xEF,0x68,0x6D,
0x97,0x29,0x63,0x86,0x48,0xDD,0x4F,0x5D,0x47,0x34,0xFF,0x00,0xBB,0x73,0x91,0x91,
0x44,0x8A,0xC5,0xF3,0xFB,0xB5,0x4E,0x17,0xBF,0xB9,0x81,0x9D,0x76,0x97,0xBA,0xFD,
0xFD,0xEE,0x1B,0x57,0x5D,0x6F,0xD5,0xDE,0x9A,0x77,0x0D,0x1C,0xD3,0xF8,0x2D,0xF2,
0xC8,0xFC,0x87,0x32,0xCA,0xE8,0xEA,0xEE,0x95,0x95,0x5C,0xB7,0xD2,0x86,0x2A,0x1A,
0x64,0x5E,0xD6,0x79,0x72,0xB9,0xD2,0x39,0x38,0xE1,0x38,0x2C,0x2E,0x99,0xFB,0x4F,
0xDC,0x0E,0x84,0xF5,0x17,0xDE,0x9E,0xB5,0xEA,0xB6,0x9E,0x4B,0x69,0xC5,0xF5,0x47,
0x27,0xB4,0xD7,0xE2,0xF7,0x57,0xD4,0xC3,0x2B,0x6E,0xD0,0x43,0x4F,0x50,0xD9,0x1E,
0xD6,0x31,0xCA,0xE6,0x23,0x56,0x56,0x27,0x0F,0x46,0xAF,0x9F,0x08,0xA0,0x71,0xD0,
0x8D,0xA2,0x6B,0xAE,0x3D,0xD6,0xFF,0x00,0x72,0x5B,0xA0,0xCD,0x74,0xDA,0x48,0x74,
0xDB,0x3E,0xC2,0x2C,0x36,0x6B,0x55,0xFA,0x4A,0x98,0x5D,0x1D,0xC6,0x68,0x61,0x89,
0x95,0x11,0x24,0x6D,0x7A,0xC8,0xD5,0x6F,0x63,0xD1,0x55,0xCD,0x44,0xFC,0x95,0x4C,
0x15,0xB2,0xFC,0x3B,0xA9,0xBF,0x45,0x6C,0x63,0x20,0xD9,0x3E,0x25,0xD3,0xE2,0xE5,
0xAF,0xFA,0x4F,0x49,0x7C,0xAD,0xB8,0xE0,0xF9,0xAE,0x09,0x90,0xD0,0xD0,0xD6,0x53,
0x52,0xD5,0x4A,0xB2,0xFD,0x92,0xBA,0x9A,0xA5,0x51,0x5A,0xF6,0xB9,0xDC,0xAB,0xD3,
0xC2,0x2A,0xBB,0x85,0x72,0x76,0xF0,0x12,0x93,0x2D,0x97,0x7B,0x7B,0xC0,0xE9,0x97,
0xAD,0x58,0xD6,0xB8,0x6D,0x32,0x8B,0x4D,0xB3,0xFC,0xBB,0x1D,0xBE,0x5A,0x71,0xDD,
0x3E,0xA3,0xC9,0x20,0xBB,0xCE,0xF8,0x66,0xA0,0x56,0x53,0x7D,0xA2,0xA9,0x88,0xC8,
0x19,0x3C,0x92,0xBD,0xE8,0xAD,0x6A,0xAB,0x5A,0x88,0xD5,0x57,0x72,0xAB,0xC5,0xC3,
0xD2,0xB3,0x41,0xB5,0x53,0x41,0x7A,0x5E,0xE9,0x0E,0xDF,0x75,0x7E,0xC7,0x51,0x8C,
0xE5,0xD8,0xFE,0x25,0x05,0xB2,0xE3,0x43,0xEA,0xC7,0x2C,0xB6,0xFA,0x8E,0xD7,0xA2,
0xA7,0x7C,0x6E,0x73,0x15,0xCD,0x57,0x22,0xFC,0xAE,0x54,0xE5,0x3D,0xC0,0x81,0x7D,
0x3B,0x74,0x3B,0xAA,0x67,0x4E,0x8D,0xBC,0xE4,0x3D,0x3F,0xB1,0x1E,0x97,0x76,0x0C,
0x9F,0x32,0xAE,0xBC,0xDC,0x5D,0x06,0xE0,0xEE,0x19,0x2D,0x0C,0x78,0xF5,0xDA,0x2A,
0xA9,0x1C,0xAD,0xB8,0xDC,0x3C,0x3A,0xB5,0xEB,0x13,0x1D,0xC7,0xA2,0xD6,0xFA,0x8E,
0x46,0x35,0xBF,0x2A,0xF2,0xA6,0x4F,0xD8,0x97,0x4C,0x3D,0xCB,0x63,0xDF,0x0E,0xBE,
0x4B,0xD3,0x6F,0x56,0xB1,0xA8,0x31,0x8D,0x43,0xBD,0x5A,0x32,0x6B,0x6D,0x3D,0x2D,
0x7D,0x4C,0x72,0x42,0xC9,0xAA,0x6A,0xEA,0x24,0xA4,0x7B,0xE4,0x89,0xCF,0x6A,0x31,
0xFC,0xC6,0xE5,0xE1,0x55,0x51,0xAE,0xF2,0x9C,0xA2,0xA0,0x0D,0xAF,0x68,0x66,0xF7,
0x37,0x8F,0xD3,0x1A,0xFD,0xD2,0x6F,0x7B,0x3B,0x21,0xB9,0x68,0xED,0x25,0x93,0x4E,
0x61,0xC4,0xE9,0xF5,0x26,0xAB,0x20,0xA3,0xB9,0x52,0xDC,0xEB,0xE9,0xFD,0x38,0xE9,
0x64,0x86,0x92,0x05,0x57,0xF6,0x37,0xD1,0x64,0xCF,0x55,0x7F,0x1F,0x2A,0xB5,0x3D,
0xD1,0x4F,0x2F,0x40,0x77,0x17,0xD7,0x97,0x6B,0x9B,0x61,0xB1,0x6C,0xAA,0xBF,0xA5,
0x04,0x39,0x9E,0x75,0x86,0xDA,0xE2,0xC7,0x2C,0xDA,0xAB,0x6F,0xCD,0x68,0x23,0xC6,
0xEB,0x60,0x82,0x36,0xC3,0x4D,0x5B,0x3C,0x6F,0xE2,0x54,0xEC,0x62,0x31,0x5C,0xCE,
0x5A,0xE7,0xF6,0x2A,0xF0,0xC5,0x55,0x44,0x0F,0x76,0xCB,0xD2,0x4F,0x5B,0xB6,0xE1,
0xF0,0xFF,0x00,0x6A,0x9E,0xC6,0xF1,0x59,0xA1,0xCE,0xF5,0x7B,0x3E,0xB4,0xDD,0x2E,
0xF7,0x67,0x5B,0x25,0x64,0x30,0xDD,0x2F,0x55,0xAF,0x63,0xDE,0xC8,0x9F,0x2F,0x63,
0x7B,0x5A,0xD8,0xD9,0x1A,0x39,0xFD,0xBD,0xDE,0x9A,0xBB,0x86,0xF7,0x70,0x93,0x67,
0x60,0x7A,0x71,0x9A,0x68,0xEE,0xC6,0xF4,0x73,0x49,0xB5,0x1E,0xCA,0xEB,0x6E,0x43,
0x8C,0x61,0x36,0x7B,0x55,0xCE,0xDE,0xF9,0x19,0x22,0xD2,0xD4,0xC1,0x45,0x14,0x72,
0xC6,0xAE,0x62,0xAB,0x5C,0xAD,0x7B,0x5C,0x9C,0xB5,0x55,0x17,0x8F,0x0A,0xA0,0x65,
0xD0,0x00,0xA7,0x28,0x03,0x94,0x38,0xBA,0x56,0xA7,0xB7,0x2B,0xC7,0xD1,0xBE,0x40,
0xC5,0x9A,0xF7,0xBE,0x2D,0x9F,0x6D,0x66,0x8D,0xF5,0x7B,0x8C,0xDC,0xE6,0x0B,0x85,
0x7A,0x69,0xCF,0xA1,0x91,0x5E,0xE9,0xE9,0xA7,0x7F,0xFA,0x30,0xAB,0xBD,0x47,0x2F,
0xF0,0x46,0xAA,0x90,0x53,0x71,0x3F,0x16,0xE7,0x49,0x0D,0x1B,0x4A,0x8A,0x0D,0x3A,
0xCB,0x73,0x1D,0x4E,0xAF,0x8B,0xE5,0x6C,0x78,0x6D,0x95,0xF0,0xD3,0xB9,0xDE,0x3D,
0xEA,0x2A,0xD6,0x16,0xAA,0x79,0xF7,0x6A,0x38,0x08,0x25,0xB8,0x1F,0x8D,0x67,0x70,
0x79,0x35,0x44,0xB6,0x4D,0xA7,0xEC,0xC3,0x19,0xB0,0x2C,0x8B,0xE9,0x41,0x5D,0x9A,
0x5C,0xA7,0xBB,0xD4,0x3D,0x57,0xC2,0x2A,0x53,0xC0,0x90,0x35,0x1D,0xCF,0xD3,0xB9,
0xE6,0x21,0x4D,0xCC,0x7C,0x58,0x3D,0x4F,0x1A,0xE6,0x69,0xD5,0x0E,0xAF,0xDB,0xAC,
0x17,0x04,0xED,0x8D,0xF8,0xA5,0xA9,0x98,0x85,0xB3,0xB1,0xDF,0xD1,0xAD,0x56,0xC2,
0xAF,0x6F,0x0E,0xFA,0xCA,0xEF,0xEB,0x02,0xEC,0xD2,0x8F,0x84,0x13,0xA9,0xD6,0xE1,
0xAF,0x7F,0xB6,0xDB,0xBF,0xDC,0xBE,0x21,0x8A,0xD4,0x55,0xAF,0x35,0x13,0x5C,0x6E,
0x15,0x39,0x2D,0xDB,0x95,0xF2,0xBD,0xDD,0xBC,0x46,0xAB,0xFF,0x00,0xAF,0x5F,0x72,
0x6E,0xED,0xEB,0xE0,0xCD,0xE9,0xE1,0xA7,0x6B,0x15,0xC3,0x5F,0xF5,0x7F,0x50,0xB5,
0x26,0xAD,0x9C,0x77,0xD2,0x36,0xA6,0x2B,0x2D,0x04,0x9F,0x9F,0xEE,0xE1,0x47,0x4C,
0x9F,0xFF,0x00,0x30,0x13,0xBB,0x6E,0xBD,0x1F,0xFA,0x65,0xED,0x51,0xF0,0xD4,0xE8,
0x7E,0xC9,0xF4,0xFE,0xD7,0x59,0x4F,0xC7,0xA7,0x77,0xAD,0xB6,0x36,0xE3,0x5E,0xC5,
0x4F,0xAA,0x55,0x54,0xFA,0x92,0xA2,0xFE,0x8E,0x42,0x48,0x43,0x47,0x4F,0x4F,0x03,
0x69,0xA1,0x89,0xAD,0x8D,0x88,0x8D,0x6C,0x6D,0x4E,0x1A,0xD4,0x4F,0x64,0x44,0xF6,
0x44,0x03,0x9A,0x46,0xC4,0xFC,0x28,0x89,0xFA,0x15,0x44,0x44,0xF6,0x02,0xA0,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x71,0xEC,0x4F,0xE0,0x05,0x3D,0x16,0x27,0x2A,0x89,
0xC7,0xE9,0xCA,0x18,0x5B,0x72,0x3D,0x39,0xF6,0x2F,0xBB,0xA8,0x66,0x66,0xE4,0x76,
0xA1,0x81,0x65,0xD3,0xCD,0xCF,0x37,0x2B,0xA5,0xA2,0x24,0xAE,0x6F,0xBF,0xE1,0xAA,
0x62,0x36,0x66,0xAF,0x95,0xF2,0x8F,0x40,0x35,0xF9,0xB9,0x4F,0x83,0x9F,0xA6,0x9E,
0xAB,0x3A,0x7B,0xA6,0x82,0xE6,0x59,0xD6,0x96,0x57,0x48,0xAA,0xB1,0xC1,0x41,0x5C,
0xDB,0xBD,0xBD,0x8A,0xBF,0x9C,0x35,0x3C,0xCB,0xC7,0xF0,0x49,0xD0,0x81,0x9A,0xC5,
0xF0,0x86,0x75,0x3D,0xDB,0x76,0x41,0xFB,0x77,0xB3,0x2D,0xC6,0xE2,0xD9,0x7C,0xD4,
0x6A,0xAB,0x4D,0x3D,0xB2,0xE3,0x3E,0x33,0x79,0x45,0xE5,0x15,0x3B,0x7B,0x95,0x62,
0x45,0xFF,0x00,0xF7,0x09,0xEC,0x05,0x9E,0xCD,0xFF,0x00,0x7C,0x52,0x5D,0x2B,0x15,
0x94,0x5A,0xE7,0x6A,0xD4,0xCA,0xEC,0x7E,0x81,0x38,0x7A,0xEA,0x55,0x8B,0xF6,0x8E,
0xD8,0xE4,0x6F,0x09,0xC7,0xDE,0x4C,0x47,0xBB,0x8F,0x6F,0xC3,0x50,0x84,0x8B,0xDB,
0x5F,0xC6,0xD1,0x74,0x89,0x21,0xB5,0xEE,0xF3,0x65,0x70,0xCE,0x9E,0x3D,0x5B,0xDE,
0x9B,0x5D,0x55,0x8B,0xFC,0x55,0x28,0xAA,0xB9,0x4F,0xCB,0xFF,0x00,0x2E,0x80,0x6C,
0x1F,0x6D,0x7F,0x13,0x57,0x47,0x9D,0xC7,0x2C,0x16,0xF4,0xDC,0xE3,0x70,0x5B,0xA4,
0xDC,0x7F,0x82,0xF5,0x22,0x86,0x5B,0x52,0xB7,0x9F,0xCE,0xA7,0xE6,0xA6,0xFA,0x7F,
0xE7,0x7E,0xA4,0xE0,0xD3,0xFD,0x52,0xD3,0x8D,0x58,0xB0,0x47,0x96,0x69,0x6E,0x7D,
0x65,0xC9,0x6D,0x53,0x79,0x8E,0xE7,0x8F,0x57,0xC5,0x5B,0x4E,0xFF,0x00,0xD2,0x48,
0x9C,0xE6,0xAF,0xFA,0xC0,0xF7,0x99,0x23,0x5E,0x9C,0xB5,0xDC,0xFF,0x00,0x59,0x5E,
0x53,0xF3,0x02,0xA0,0x00,0x00,0x3E,0x80,0x41,0x7E,0xAD,0x7B,0x00,0xDC,0xF6,0xBC,
0x6B,0x0E,0x8A,0x6F,0x9F,0x62,0x79,0x2E,0x2D,0x4B,0xAB,0xDA,0x11,0x72,0xAB,0x9A,
0x86,0xCB,0x9A,0xBE,0x48,0xED,0x97,0xFA,0x1A,0xC6,0x36,0x3A,0x8A,0x69,0x24,0x67,
0x2A,0xC7,0x76,0xB5,0xC8,0x8B,0xE3,0x94,0x95,0xFF,0x00,0x33,0x55,0x1A,0xA6,0x17,
0xCD,0x7A,0x7F,0xF5,0x7F,0xDD,0xFE,0xF1,0xF6,0xF1,0xBC,0xDD,0xDC,0xE6,0x5A,0x61,
0x61,0xB7,0xE9,0x5E,0x65,0x15,0xC5,0x34,0x97,0x0B,0xAB,0x9A,0x4A,0x5B,0x3D,0x02,
0x47,0xCC,0xF5,0x6F,0xAC,0x91,0xAA,0xEA,0xAA,0xC9,0x1E,0xC6,0x31,0x23,0x6F,0x11,
0xB1,0x8D,0x4E,0x17,0x97,0x38,0x0C,0xA9,0xD4,0xA3,0x64,0xDB,0xD9,0xBD,0xEF,0x9B,
0x46,0xFA,0x94,0xEC,0x16,0x93,0x06,0xBF,0xE5,0xDA,0x73,0x68,0xB8,0x63,0x57,0x6C,
0x27,0x3E,0xAD,0x96,0x86,0x9E,0xE9,0x43,0x54,0x8F,0x56,0xBE,0x2A,0x88,0xDA,0xBD,
0xAF,0x63,0xA5,0x93,0xC2,0xF1,0xE7,0xB1,0x53,0xB9,0x11,0xCD,0x5F,0xDF,0x75,0x5B,
0x26,0xDE,0x7E,0xEC,0x75,0xAF,0x65,0x1B,0x82,0xCE,0x68,0xF0,0x3A,0x0B,0xE6,0x8D,
0xE4,0x55,0x17,0xEC,0xF6,0x86,0xCF,0x70,0x9D,0x29,0x21,0x74,0xD0,0xC0,0x8A,0xCA,
0x1F,0x51,0x8A,0xF9,0x91,0xAE,0x85,0xC9,0xF3,0xAB,0x57,0xD9,0x7D,0x97,0xC0,0x5C,
0x56,0x2D,0x89,0x6B,0x75,0xB7,0xAE,0xA5,0xCF,0xA8,0x8D,0x45,0x45,0x8D,0x74,0xFE,
0xB3,0x48,0xD9,0x85,0xC6,0xC6,0xD5,0xBB,0xEF,0x0F,0xB7,0xA5,0x7C,0x53,0xF9,0x83,
0xB3,0x8F,0x4F,0xB2,0x35,0xF9,0xBB,0xBD,0xD5,0x13,0x83,0xF6,0xE9,0xA3,0xB1,0xBD,
0x6C,0xDA,0x76,0xE7,0x37,0x59,0xAB,0x7A,0xA5,0x51,0x64,0x75,0xAB,0x59,0x35,0x0D,
0x72,0x6C,0x7D,0x2D,0x55,0x6E,0x9A,0x54,0xA4,0x54,0x9B,0xFE,0xCE,0xD5,0x63,0x7D,
0x37,0xFE,0xF5,0xA9,0xDA,0x8A,0xEF,0x65,0xF3,0xED,0xC8,0x62,0x8E,0x9A,0x9B,0x2C,
0xEA,0x7D,0xD3,0x93,0x5B,0x32,0x2D,0xB2,0xE3,0x56,0x1D,0x24,0xC8,0xF6,0xF5,0x7F,
0xCE,0x6E,0x59,0x5C,0x59,0xA5,0x5D,0xC6,0xAA,0x2B,0xFD,0x0D,0x1D,0x5B,0x7B,0xBE,
0xCA,0xDA,0x36,0xB5,0x18,0xE9,0x91,0xEC,0x89,0x39,0x55,0x56,0x27,0xEF,0x17,0x95,
0xE5,0xA8,0x91,0xCB,0xE2,0x44,0xDA,0x96,0x4D,0xA9,0xDD,0x40,0x76,0xF9,0x8B,0x6D,
0xE7,0x52,0x12,0xC5,0x99,0x6E,0x3E,0x82,0xA7,0x4B,0x72,0xBB,0x65,0x0A,0x7E,0xFA,
0xBE,0xC3,0x1D,0x5D,0x2D,0x5B,0xEA,0x1C,0x9C,0x2A,0x7A,0x71,0x22,0xBF,0xB9,0x57,
0x85,0x54,0x8D,0x88,0x9C,0xA2,0x2F,0x01,0xB9,0x7D,0x3C,0xC2,0xF1,0x9D,0x37,0xC1,
0xEC,0xFA,0x79,0x85,0xDB,0x19,0x45,0x66,0xB0,0xD0,0xC3,0x6E,0xA0,0xA3,0x8B,0xF0,
0xC1,0x4F,0x0C,0x6D,0x8E,0x26,0x27,0xF0,0x46,0x31,0xA8,0x7B,0x40,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3E,0x84,0x7D,0xDF,
0xCF,0x4E,0x1D,0x08,0xEA,0x1B,0x8B,0x63,0x96,0xAD,0x57,0xBC,0x65,0x18,0xF5,0xFB,
0x09,0xB8,0xAD,0xE3,0x18,0xCE,0x30,0x6B,0xA3,0xAD,0xD7,0x9C,0x7E,0xB1,0x5A,0x8D,
0x59,0x60,0x99,0x11,0x53,0xCF,0x6B,0x79,0x6B,0x9A,0xA8,0xAA,0xC6,0xAF,0x85,0x44,
0x50,0x30,0xBD,0x9F,0xA1,0x96,0x03,0x99,0xE7,0x98,0xDE,0x61,0xBC,0x8D,0xEC,0x6B,
0xA6,0xBD,0xDB,0x71,0x0A,0xD8,0xAE,0x56,0xBC,0x2F,0x52,0xEF,0xB0,0x3A,0xC6,0xCA,
0xA8,0x97,0x98,0xE7,0x9A,0x92,0x9E,0x18,0xD2,0x77,0xB5,0x7D,0xBD,0x45,0x54,0x5F,
0x28,0xA8,0xA8,0xAA,0x8B,0x39,0x99,0x12,0x76,0xF0,0xF4,0x45,0x02,0xAD,0x82,0x36,
0x27,0x0D,0x6A,0x21,0x54,0x89,0x88,0xBC,0xA3,0x53,0x95,0xFC,0x90,0x0A,0xF6,0x31,
0x57,0x9E,0x13,0x93,0x8B,0xA1,0x8D,0xCB,0xCA,0xB1,0x17,0x8F,0xCC,0x0A,0xFA,0x4C,
0xF6,0xED,0x41,0xE9,0xB3,0x8E,0xD4,0x44,0xE1,0x00,0xA7,0xA1,0x1F,0x3D,0xDD,0xA9,
0xCF,0xE6,0x55,0x22,0x62,0x7B,0x35,0x00,0xA2,0x41,0x13,0x57,0x94,0x62,0x73,0xF9,
0x85,0xA7,0x89,0x57,0xB9,0x58,0xDE,0x7F,0x30,0x39,0x76,0x37,0x8E,0x15,0x02,0x76,
0xA7,0x84,0x01,0xDC,0x88,0x9C,0xF2,0x7E,0x72,0x55,0x47,0x1B,0x55,0xEA,0xEF,0x95,
0xBE,0x55,0xDF,0x44,0xFD,0x54,0x08,0xFF,0x00,0xB8,0x6E,0xAB,0x7D,0x38,0xF6,0xA6,
0x92,0xC3,0xAF,0x9B,0xCF,0xD3,0xEB,0x0D,0x5C,0x1C,0xFA,0x96,0x9F,0xBD,0xE3,0xAB,
0xAF,0x4E,0x3D,0xFF,0x00,0xBD,0x20,0xF5,0x26,0x5F,0x7F,0xE8,0x10,0x3B,0x70,0xDF,
0x18,0xFF,0x00,0x4D,0x6D,0x36,0x6C,0xD4,0x1A,0x19,0xA7,0xFA,0x85,0xA9,0x75,0x8C,
0xE7,0xD3,0x9E,0x9A,0x85,0x96,0x8A,0x19,0x3F,0x2E,0x65,0xA8,0x77,0xAA,0x89,0xFF,
0x00,0xA9,0x50,0x20,0xF6,0xB2,0x7C,0x63,0x1D,0x44,0x35,0xBA,0xF0,0xB8,0x6E,0xD0,
0xB6,0xB7,0x87,0x62,0x92,0x56,0x39,0x5B,0x4E,0xC7,0x41,0x53,0x91,0xDD,0x3F,0x24,
0xED,0x4F,0xDD,0xC7,0xCF,0x94,0xF1,0xE8,0xBB,0xCF,0xE6,0x59,0x4B,0xA5,0x7F,0x16,
0x67,0x54,0x06,0x7A,0x99,0x35,0x4E,0xB2,0xDB,0x6C,0x37,0x1E,0x5C,0xF6,0xDE,0x2B,
0x23,0xC2,0xED,0x6A,0xC5,0xE7,0xDE,0x9D,0x16,0x9F,0xD4,0x6F,0x0B,0xC7,0x86,0x3D,
0x7F,0x50,0x32,0x8E,0x81,0x7C,0x16,0x7B,0xA9,0xCE,0x6B,0x23,0xBF,0xEE,0xC7,0x78,
0xD8,0x8E,0x34,0xB3,0xBB,0xD4,0x9E,0x9B,0x16,0xA3,0xA8,0xBE,0x56,0x3F,0xDF,0x94,
0x74,0xD2,0xFA,0x0C,0x47,0x7B,0x79,0xF9,0xD0,0x9D,0x7B,0x77,0xF8,0x43,0x3A,0x50,
0xE9,0x07,0xD9,0xEE,0x3A,0xA7,0x45,0x9B,0xEA,0x7D,0x6C,0x6A,0x8E,0x7A,0x65,0x17,
0x95,0xA4,0xA4,0x73,0xBF,0x84,0x14,0x8D,0x89,0x78,0xFE,0x0E,0x7B,0x80,0x9D,0xBB,
0x7C,0xE9,0xFB,0xB2,0x5D,0xAA,0x41,0x14,0x5B,0x75,0xDA,0x96,0x01,0x87,0xCB,0x0F,
0x84,0xAE,0xB2,0xD9,0x60,0x8E,0xAD,0xDE,0xDE,0x5D,0x50,0xAD,0x59,0x5C,0xBE,0x13,
0xCB,0x9C,0xAA,0x66,0x0F,0x45,0x8A,0x9F,0x32,0x73,0xC7,0xE7,0xCA,0x81,0x54,0x8D,
0xA9,0xF4,0x43,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xF7,0x38,0xAC,0x6D,0x5F,0xA2,0x01,0xC5,0xD4,0xF1,0x39,0x8B,0x1A,0xB1,0x3B,
0x57,0xDD,0xBF,0x45,0xFE,0xA2,0x38,0xEE,0x5B,0xA4,0x47,0x4D,0x6D,0xDD,0x2C,0xF5,
0x1A,0xF9,0xB3,0x2C,0x0E,0xEF,0x5D,0x53,0xCF,0xA9,0x7A,0xA4,0xB7,0xA5,0xBE,0xE2,
0xE5,0x5F,0xAF,0xDA,0xE9,0xBD,0x39,0x55,0x7F,0x57,0x28,0x1A,0xF9,0xDC,0xAF,0xC1,
0x7F,0xB1,0xAD,0x40,0x6D,0x45,0xCF,0x6C,0xDA,0xFD,0x9C,0xE9,0xCD,0x6C,0x88,0xAB,
0x1D,0x0D,0xD3,0xD2,0xBE,0xDB,0xD8,0xBE,0x78,0x44,0x6B,0xFD,0x39,0xD1,0x3D,0xBD,
0xE5,0x72,0xFE,0xA4,0x1F,0xD4,0x3F,0x85,0xB3,0xAD,0x6E,0xCA,0x72,0x29,0xB5,0x03,
0x65,0x7A,0xCD,0x6C,0xC9,0xA5,0x83,0xE7,0x86,0xB3,0x4E,0xF2,0x59,0xB1,0xFB,0xB3,
0x91,0x39,0x5F,0x31,0x4C,0xB1,0x37,0x9F,0x09,0xE1,0xB3,0x38,0x0F,0x2A,0x8B,0xAD,
0x3F,0xC4,0x9F,0xD3,0x1A,0xBE,0x3B,0x26,0xEB,0x71,0x4C,0xA2,0xE9,0x6A,0xA4,0x7A,
0x37,0xD2,0xD6,0x4C,0x51,0xF3,0xC1,0x2A,0x22,0xF9,0xED,0xB9,0x44,0xD8,0xDF,0x27,
0x3C,0x7E,0x2F,0x59,0xDF,0x9F,0x92,0x57,0x6D,0x9F,0xE3,0x66,0xD3,0x2B,0x93,0xA9,
0xED,0x5B,0xBB,0xD9,0x9D,0xE6,0xCE,0xEE,0xE4,0x6C,0xD7,0xBD,0x3C,0xB9,0xB2,0xBE,
0x35,0xE7,0x8E,0x5D,0xF6,0x4A,0x8F,0x4D,0xCD,0x4F,0x75,0xE1,0x26,0x72,0x81,0xB0,
0x7D,0xB4,0x7C,0x43,0x5D,0x21,0xF7,0x47,0xF6,0x7A,0x0C,0x3F,0x78,0xF8,0xFE,0x3F,
0x74,0xA8,0xE1,0x3E,0xE7,0xCF,0x92,0x4B,0x14,0xCD,0x72,0xF1,0xF2,0xF7,0xD4,0x23,
0x61,0x72,0xF9,0xFE,0x64,0x8E,0x26,0x3E,0x3B,0x94,0xE3,0xD9,0x6D,0xA2,0x1C,0x83,
0x16,0xBE,0x52,0x5C,0xA8,0x2A,0x5B,0xDF,0x15,0x75,0xBE,0x76,0xCF,0x0C,0x89,0xF9,
0xA3,0xD8,0xAA,0xD5,0x4F,0xD1,0x40,0xEF,0xA3,0xDA,0xA9,0xCA,0x3B,0xFF,0x00,0x79,
0x5E,0x53,0xF3,0x02,0xA0,0x0E,0x2B,0x1B,0x57,0xDD,0x10,0x7A,0x4C,0x4F,0xA2,0x00,
0xF4,0xDB,0xF9,0x27,0xFA,0x82,0x46,0xDF,0xC9,0x00,0x7A,0x4C,0xF6,0xE1,0x07,0xA6,
0xDF,0xC9,0x00,0x23,0x1B,0xCF,0x3C,0x21,0x87,0xF2,0x5D,0x8B,0xED,0xE3,0x31,0xDE,
0x66,0x3D,0xBF,0x3C,0xA3,0x1B,0xAF,0xAE,0xD4,0x4C,0x4E,0xC7,0x2E,0x3F,0x67,0xAE,
0xA8,0xB8,0x4C,0xB4,0xB6,0xEA,0x79,0x5D,0x22,0xC8,0xE8,0xE9,0x79,0xF4,0xD2,0x57,
0x24,0xD2,0x35,0x64,0xE3,0xB9,0x5A,0xEE,0x3E,0x88,0x06,0x61,0x6B,0x51,0xA9,0xC2,
0x21,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xB2,0x37,0x1B,0xB8,0x2D,0x31,
0xDA,0xB6,0x88,0x64,0xDB,0x86,0xD6,0x6B,0xBD,0x4D,0x06,0x2D,0x88,0xD0,0xBA,0xE1,
0x73,0xAC,0xA4,0xA4,0x92,0xAA,0x48,0x61,0x6A,0xA2,0x39,0xC9,0x14,0x68,0xAF,0x77,
0x1C,0xA7,0xB2,0x2F,0x8E,0x55,0x7C,0x21,0xA8,0xCD,0xC5,0xFC,0x69,0xDB,0x3A,0xC3,
0x3E,0xD3,0x41,0xB6,0x7D,0xB0,0xE7,0x59,0xCD,0x4C,0x68,0xAD,0x8E,0xBB,0x22,0xA8,
0x82,0xC7,0x44,0xF5,0xF3,0xC2,0xA7,0x1E,0xBC,0xAA,0x9C,0xFE,0x6C,0x6A,0xFF,0x00,
0xC8,0x04,0x36,0xCE,0xFE,0x2A,0x2E,0xB4,0xBB,0xC2,0xBF,0x4D,0x84,0x6C,0xD3,0x43,
0xEC,0x98,0xE4,0x92,0xF2,0xC8,0x69,0xB0,0x2C,0x66,0xA3,0x21,0xBA,0x37,0x9E,0x7D,
0xDF,0x2A,0x4A,0xCE,0x78,0x54,0xF2,0x90,0xB7,0xDB,0x9F,0x07,0x8E,0xBD,0x30,0x3E,
0x28,0xEE,0xA6,0x0F,0xFB,0x4E,0xE1,0xB2,0x3D,0x42,0xB6,0xD9,0x6B,0x3C,0xB9,0xBA,
0xA5,0x95,0xFD,0xD1,0x42,0xCE,0x79,0xFF,0x00,0xEA,0xD8,0xDD,0xDE,0xDF,0xD1,0x29,
0xFE,0xA0,0x48,0x0D,0xBB,0x7C,0x12,0x59,0x14,0xCB,0x0D,0xC7,0x75,0x9B,0xDE,0xA3,
0xA5,0x6A,0x71,0xEB,0x5A,0x34,0xEE,0xCE,0xE9,0x9C,0xBF,0x9A,0x25,0x5D,0x4A,0xB5,
0x13,0xF5,0xF4,0x54,0x9D,0xFB,0x78,0xF8,0x57,0x7A,0x3C,0xE8,0x2A,0xC1,0x5D,0x7B,
0xD0,0xCB,0xAE,0xA1,0xDC,0x60,0xE3,0x8A,0xDD,0x41,0xBC,0xCB,0x54,0xC7,0x2F,0x8E,
0x55,0x69,0xA1,0xF4,0xA0,0x54,0xE5,0x3D,0x9C,0xC5,0xF7,0xFA,0x81,0x38,0xB4,0x63,
0x6C,0xDB,0x78,0xDB,0xAD,0x95,0x98,0xF6,0x82,0x68,0x66,0x21,0x85,0x50,0xB1,0xA8,
0xCF,0xB3,0x62,0xB6,0x88,0x28,0x1A,0xA8,0x89,0xC7,0x9F,0x49,0x8D,0x55,0xF6,0xF7,
0x55,0x52,0xF7,0xF4,0x63,0xE7,0xBB,0x84,0x55,0xFC,0xD7,0xDC,0x0E,0x48,0xC6,0x95,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x07,0x17,0x46,0xD7,0x7B,0xA2,0x7F,0x58,0x1D,0x7B,0x8D,0xA6,0xDF,0x74,
0xA1,0x96,0xDB,0x70,0xA3,0x8A,0xA2,0x9E,0x66,0xAB,0x1F,0x4F,0x3B,0x11,0xF1,0xBD,
0x17,0xDD,0x15,0xAB,0xCA,0x2A,0x7E,0xA4,0x4F,0xDC,0xB7,0x42,0x9E,0x94,0x3B,0xAE,
0x5A,0x8A,0xCD,0x54,0xD9,0x4E,0x1D,0x4F,0x72,0xA9,0xE5,0x5D,0x7A,0xC5,0x21,0x75,
0x92,0xB1,0x5D,0xFD,0x25,0x92,0x91,0x63,0xEF,0x5F,0xF4,0xD1,0xC0,0x6B,0xE7,0x72,
0xDF,0x05,0x26,0xDB,0x72,0x56,0xD4,0xDD,0x36,0xA3,0xBB,0x7C,0xB3,0x11,0x99,0xDF,
0x3C,0x76,0xAC,0xCE,0x8A,0x2B,0xCD,0x2F,0x3E,0x3E,0x54,0x96,0x2F,0x42,0x46,0xA7,
0xF1,0x54,0x7A,0xFE,0xA4,0x39,0xBF,0xFC,0x3D,0x7F,0x10,0x77,0x4E,0xBB,0xCC,0xD9,
0x6E,0xCD,0xF5,0x0E,0xB2,0xF3,0x4F,0x03,0xBD,0x4F,0xB6,0x68,0xEE,0x5F,0x2D,0x0C,
0xD2,0x35,0x3F,0xA7,0x47,0x32,0xC0,0xE7,0xAF,0x95,0xF9,0x51,0xAF,0xFE,0xB0,0x39,
0xE3,0x1F,0x11,0xAF,0x5F,0x9E,0x9F,0x37,0xB8,0x30,0xBD,0xE6,0x69,0xAC,0x97,0xC8,
0xE0,0x77,0xA4,0xB4,0x7A,0xBB,0x89,0x4B,0x6C,0xAB,0x7B,0x53,0x9F,0x0C,0xAA,0x85,
0xB0,0x2B,0x97,0xFC,0xE5,0xEF,0xF6,0xFA,0x93,0x37,0x6D,0x1F,0x1A,0x8E,0xD5,0xF2,
0xEF,0xB3,0xDB,0x37,0x55,0xB5,0x7C,0xC7,0x0A,0xA8,0x77,0xC8,0xFB,0x9E,0x25,0x57,
0x15,0xEA,0x8D,0x17,0xFA,0x4A,0xC7,0xA4,0x32,0xB5,0x3F,0x82,0x23,0xD4,0x0D,0x83,
0xED,0xA7,0xAD,0xFF,0x00,0x4A,0xCD,0xD9,0x25,0x3D,0x26,0x90,0x6F,0x5B,0x0B,0xFB,
0xC6,0xA7,0x84,0x65,0x93,0x24,0xAA,0x5B,0x35,0x73,0x9C,0xBC,0x7C,0xA9,0x0D,0x5A,
0x46,0xE7,0x2F,0x9F,0xE6,0x77,0x12,0x9E,0x92,0xE1,0x49,0x5D,0x4C,0xCA,0xDA,0x3A,
0x86,0x4B,0x04,0xAD,0x47,0xB2,0x68,0x9C,0x8E,0x63,0xD1,0x7D,0x95,0x1C,0x9E,0x15,
0x3F,0x40,0x3F,0x74,0x54,0x5F,0x28,0xA5,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x02,0xD4,0xD7,0x1D,0x1E,0xC2,0xF7,0x05,0xA3,0x99,0x5E,
0x85,0x6A,0x35,0x24,0x93,0xD8,0x33,0x2B,0x45,0x55,0x92,0xE3,0x14,0x0F,0x46,0x48,
0xEA,0x7A,0x88,0x5D,0x14,0x9D,0xAE,0x54,0x54,0x47,0x76,0xBD,0x78,0x5E,0x17,0x85,
0x44,0x5F,0x3C,0x11,0x03,0x6E,0xBF,0x0D,0xFF,0x00,0x47,0x9D,0xB8,0x32,0x9E,0xAE,
0xCD,0xB3,0xFB,0x46,0x55,0x72,0x83,0x85,0x5B,0xA6,0xA0,0xD4,0xCB,0x7A,0x7C,0x8E,
0x4E,0x3E,0x65,0x8A,0x57,0x7A,0x08,0xBE,0x39,0xF9,0x62,0x40,0x26,0x6E,0x07,0xA6,
0xBA,0x7D,0xA5,0xF6,0x18,0xF1,0x6D,0x36,0xC1,0xEC,0xF8,0xF5,0xB2,0x14,0xE2,0x3B,
0x75,0x8A,0x8A,0x3A,0x38,0x18,0x89,0xEC,0x89,0x1C,0x6D,0x6B,0x53,0xFD,0x47,0xB6,
0x90,0xB1,0xBE,0x51,0xA9,0xE7,0xF8,0x01,0x54,0x44,0x6F,0xB2,0x15,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x28,0xA8,0x8A,0x53,0xD2,0x62,0xF8,0x56,0xA7,0xE9,0xC0,0x1E,
0x6E,0x57,0x86,0x62,0x99,0xC5,0x8A,0x7C,0x63,0x32,0xC6,0xED,0xF7,0x7B,0x6D,0x4B,
0x7B,0x66,0xB7,0xDD,0x29,0xD9,0x53,0x04,0xA9,0xC7,0x1C,0x3A,0x37,0xA2,0xB5,0x53,
0xF5,0x42,0x18,0xEE,0x5B,0xE1,0xD1,0xE9,0x07,0xB9,0xF5,0xA8,0xAF,0xC9,0x36,0x81,
0x65,0xC5,0xAE,0x95,0x0A,0xAE,0xFB,0xE3,0x4F,0x26,0x92,0xC7,0x2B,0x1C,0xBC,0xF2,
0xEF,0x4A,0x05,0x48,0x1C,0xBC,0xAF,0x3F,0x34,0x4A,0x06,0xBE,0x77,0x2D,0xF0,0x4B,
0x61,0x55,0x9F,0x68,0xBA,0xED,0x0F,0x7A,0x37,0x1B,0x7A,0xF2,0xAB,0x0D,0x93,0x51,
0xAD,0x6D,0xAB,0x62,0xF3,0xCF,0x08,0xB5,0x94,0xDD,0x8A,0x89,0xED,0xE7,0xD0,0x72,
0xFE,0xA4,0x59,0x9B,0xA3,0xFF,0x00,0xC4,0xC5,0xD2,0xF6,0xAD,0xD7,0x4D,0xAE,0xE4,
0xD9,0x95,0xCA,0xCF,0x47,0xCA,0xF3,0xA3,0xD9,0x4B,0xAB,0xA9,0x25,0x44,0xE3,0x8E,
0xEB,0x64,0x8A,0xC7,0xBF,0xD9,0x3C,0x2C,0x0E,0x03,0xE9,0x63,0x6D,0xD6,0xBD,0x51,
0xB1,0xE8,0x06,0x11,0x66,0xD6,0xFC,0x9A,0x5B,0xD6,0x67,0x4B,0x61,0xA1,0x8E,0xFB,
0x77,0x9E,0x38,0xE3,0x75,0x65,0x7A,0x53,0xB3,0xED,0x12,0x2B,0x23,0x6B,0x58,0xDE,
0xE9,0x7B,0xD7,0x86,0xB5,0x11,0x3E,0x88,0x5E,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x05,0x15,0x11,0x7D,0xCE,0x2B,0x0C,0x6E,0xF7,0x63,0x7F,0xD4,0x07,
0x24,0x6A,0x37,0xD8,0xA8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x14,0xE5,0x07,0x28,0x05,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xE8,
0x62,0x9D,0xE0,0xEE,0x92,0x87,0x69,0x1A,0x3B,0x2E,0xA9,0xCD,0xA3,0xF9,0xCE,0x7B,
0x59,0x2D,0x6C,0x16,0xDA,0x0C,0x4B,0x4F,0x2D,0x6B,0x71,0xB9,0xDC,0x6A,0x67,0x72,
0xB6,0x36,0x35,0x9C,0xA3,0x58,0xCE,0x51,0x55,0xD2,0x3D,0xC8,0xD6,0xA2,0x79,0x5E,
0x78,0x45,0x08,0xB5,0x87,0x75,0xAB,0xCD,0xF0,0xDD,0xC4,0xE0,0x3A,0x09,0xBE,0x7E,
0x9D,0x9A,0x91,0xA1,0x30,0x6A,0xAD,0xC7,0xEE,0x7C,0x57,0x2C,0xBF,0xDC,0xE8,0x6E,
0x76,0xFA,0xCA,0xD7,0x71,0xE9,0xD3,0xCE,0xEA,0x75,0xE6,0x09,0x1E,0xAE,0x46,0xA3,
0x57,0xB9,0x79,0x72,0x73,0xC2,0x72,0xE4,0x8F,0x7D,0x46,0xFA,0x99,0x6F,0x7B,0x47,
0x7A,0xD2,0xE8,0x76,0x97,0x69,0xAE,0xD4,0xB5,0x9A,0xAF,0x18,0xB5,0x32,0xFF,0x00,
0x02,0x61,0x76,0x2B,0xB4,0x11,0x52,0xEA,0x83,0x52,0x91,0xAA,0xDA,0x98,0x22,0xEE,
0xEC,0x73,0x29,0x95,0x7B,0xD7,0xD6,0xE1,0xC9,0xC7,0x8E,0x14,0x0D,0xA2,0xED,0xBB,
0x54,0x33,0x4D,0x67,0xD1,0x5C,0x7F,0x53,0xB5,0x0B,0x45,0x6F,0xBA,0x77,0x79,0xBB,
0xC0,0xE9,0x6A,0xB0,0xCC,0x9A,0x48,0xA4,0xAE,0xB5,0xB9,0x24,0x7B,0x51,0x92,0x3A,
0x25,0x56,0x2A,0xAA,0x35,0x1E,0x9C,0x2F,0xB3,0xD3,0x94,0x45,0xE5,0x12,0xFA,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA2,0xFB,0x10,0xE3,0xAD,0x17,0x50,0x8D,
0x4F,0xE9,0xF7,0xB7,0xCC,0x4E,0xEF,0xA1,0xD8,0xBD,0x8E,0xBB,0x35,0xD4,0xBC,0xC2,
0x83,0x08,0xB2,0xDC,0x72,0xD7,0xBD,0x96,0x7B,0x34,0xF5,0x49,0x22,0xFD,0xAE,0xAD,
0x58,0xA8,0xAB,0x1B,0x1B,0x1A,0xFC,0xBC,0xA2,0x72,0xBC,0xAF,0x28,0xD5,0x45,0x0D,
0x7F,0x75,0x81,0xD2,0xDD,0xEC,0x69,0x2E,0xA5,0xED,0x22,0x87,0x78,0xFD,0x49,0xF1,
0xCD,0x4C,0xAB,0xBB,0x6B,0x5E,0x3D,0x51,0x47,0xA7,0x36,0x8C,0x22,0x8B,0x1F,0x5A,
0x47,0x32,0xA1,0x11,0xF5,0xB1,0x4A,0xC9,0x1D,0x51,0x2C,0x51,0xF7,0xA4,0x4B,0xDE,
0x9D,0xBC,0xCC,0xD5,0x55,0xE7,0x84,0x24,0xBF,0x51,0x9A,0xFB,0x6D,0x93,0xE2,0x08,
0xD8,0x6D,0x7D,0xE2,0x78,0xE9,0xE0,0xA9,0xA4,0xCB,0xE9,0x63,0x9A,0x65,0xED,0x6B,
0xE5,0x7D,0x1A,0x35,0x8C,0xE5,0x7C,0x77,0x2A,0xB9,0xA8,0x89,0xF5,0x55,0x44,0xF7,
0x50,0x36,0x59,0x47,0x2C,0x13,0x42,0xD7,0xD3,0xBD,0xAE,0x6F,0x94,0xE5,0x8A,0x8A,
0x9C,0xA2,0xF0,0xA9,0xE3,0xF8,0xA2,0x9F,0xB0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x1D,0x4B,0xD5,0xEE,0xD1,0x8E,0x5A,0x6A,0xAF,0xF7,0xFB,0xA5,0x3D,0x0D,0x0D,0x0C,
0x2F,0xA8,0xA9,0xAC,0xAB,0x95,0xB1,0x45,0x04,0x6C,0x6A,0xB9,0xCF,0x7B,0xDD,0xC3,
0x5A,0xD4,0x44,0x55,0x55,0x55,0xE1,0x11,0x15,0x54,0xFC,0x31,0x2C,0xBF,0x16,0xCF,
0x71,0xCA,0x2C,0xC7,0x08,0xC9,0x68,0x2F,0x16,0x8B,0x94,0x4D,0x9E,0x92,0xE9,0x6A,
0xA9,0x65,0x4D,0x35,0x54,0x6E,0xF6,0x7C,0x72,0xB1,0x55,0xAF,0x6A,0xFD,0x15,0x15,
0x50,0x0F,0x49,0x7C,0xA7,0x06,0x39,0xDD,0x06,0xD4,0xB4,0x03,0x79,0x9A,0x43,0x71,
0xD0,0x6D,0xCC,0xE9,0x8D,0xBB,0x2D,0xC5,0x2E,0xAA,0xC7,0xCF,0x6A,0xB8,0xF7,0x37,
0xB6,0x46,0x2F,0x2C,0x92,0x39,0x18,0xA8,0xF8,0xE4,0x6A,0xFB,0x3D,0x8E,0x47,0x27,
0x2A,0x9C,0xF0,0xAA,0x80,0x47,0xDD,0x38,0xE8,0x2B,0xD2,0xEF,0x4C,0x22,0xA0,0xA8,
0xB1,0x6D,0xC9,0xF5,0x97,0x3B,0x55,0xEE,0xDF,0x7F,0xA3,0xC8,0x2F,0xB7,0xDA,0xFB,
0x85,0xCA,0x9E,0xA2,0x86,0x45,0x92,0x95,0x8C,0xAA,0x9A,0x57,0x48,0xC8,0x18,0xE5,
0xE5,0x60,0x6A,0xA4,0x6E,0x5E,0x15,0xCD,0x72,0xA2,0x71,0x95,0x77,0xB5,0xD3,0xAB,
0x68,0xFD,0x43,0x70,0xEB,0x4E,0x15,0xBB,0x0D,0x28,0x8B,0x23,0x82,0xC1,0x56,0xB5,
0xD6,0xAA,0xEA,0x7A,0xD9,0xE8,0x6B,0x6D,0x93,0x39,0x11,0x1C,0xF8,0x6A,0x60,0x7B,
0x24,0x67,0x77,0x6B,0x79,0x6F,0x3D,0xAB,0xDA,0xD5,0x54,0xE5,0xA8,0xA8,0x17,0xDE,
0xDC,0xB6,0xF1,0xA4,0xDB,0x52,0xD1,0x6C,0x7F,0x6F,0xBA,0x1B,0x8C,0x3A,0xCF,0x8A,
0xE3,0x30,0x3A,0x9E,0x82,0xDF,0x25,0x54,0xB5,0x4F,0x8D,0xAE,0x91,0xD2,0x3D,0x5D,
0x2C,0xAE,0x74,0x8F,0x73,0x9F,0x23,0xDC,0xAE,0x73,0x95,0x55,0x5C,0xA5,0xF0,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x12,0xEA,0x52,0x8D,0x77,0x4E,0xDD,0x7C,0x6B,
0xD1,0x38,0x5D,0x39,0xC8,0x51,0x79,0xF6,0xFF,0x00,0xB9,0x95,0x06,0xB9,0xFA,0x6C,
0xF5,0xD6,0xD8,0x4E,0xCB,0xBA,0x63,0x68,0x96,0x96,0x6A,0x05,0xD3,0x32,0xC8,0x6B,
0xF1,0x5C,0x42,0x85,0x32,0x7A,0xDC,0x0F,0x1C,0xA8,0xBB,0x50,0x62,0x8B,0x2A,0xBD,
0x58,0x95,0xD5,0x31,0xF1,0x1C,0x4F,0x54,0x5E,0x7D,0x34,0x57,0x3D,0x3C,0x72,0xD4,
0xE5,0x00,0xDA,0x3D,0xAF,0x74,0x1B,0x7F,0xBC,0xED,0xE2,0x3D,0xD8,0x5B,0xF5,0x6E,
0xC8,0xED,0x38,0x96,0xCF,0xF7,0xFA,0x66,0x32,0x54,0x24,0x74,0x29,0x43,0xE9,0xFA,
0x8B,0x3B,0x9E,0xEE,0x3B,0x5A,0x8D,0x45,0xE5,0x15,0x39,0x45,0x45,0x45,0x44,0x54,
0xE0,0x87,0x54,0x7F,0x12,0xC7,0x4D,0x69,0xA5,0xA7,0xC8,0x6E,0x1F,0xDD,0x4E,0xDD,
0x81,0xD6,0x56,0x36,0x86,0x0D,0x57,0xB9,0x60,0xD5,0xF0,0xE3,0x32,0xC8,0xE7,0x76,
0xB7,0xFB,0xF3,0xB7,0x94,0x45,0x5F,0xAA,0xB1,0x3F,0x30,0x25,0x06,0xE9,0x37,0xD5,
0xB7,0x5D,0xA1,0xED,0xE2,0x0D,0xD2,0xEA,0xC6,0x5B,0x24,0xB8,0x55,0x55,0x45,0x04,
0x10,0x5E,0x2C,0x51,0xFD,0xB5,0x93,0xFD,0xB6,0x46,0x47,0x4F,0x23,0x15,0xAB,0xC3,
0xA3,0x77,0xA8,0xD7,0x77,0xA2,0xF1,0xDA,0xBC,0x91,0xF3,0xF9,0x44,0x5D,0x33,0x13,
0x5B,0x2D,0x7A,0x47,0x26,0xA2,0x64,0xB1,0x5A,0x6F,0x77,0x77,0x58,0x6D,0xFA,0x9D,
0x36,0x3F,0x51,0x1E,0x25,0x5D,0x5C,0xD7,0xAC,0x6E,0x86,0x2B,0xA3,0x91,0x23,0x7A,
0x23,0xD3,0xB5,0x64,0x6A,0x2C,0x49,0xEF,0xDD,0xDB,0xF3,0x01,0x5C,0xBB,0xE2,0x1E,
0xE9,0x9B,0x85,0x6B,0x3D,0x36,0x94,0x5D,0xF5,0x1F,0x23,0x7D,0xA2,0xAA,0xEE,0xB6,
0x16,0xEA,0x7D,0x35,0x82,0xA1,0xF8,0x8F,0xDB,0xD1,0xDD,0xAE,0xA7,0x4B,0xAF,0x1E,
0x9B,0xD5,0xAE,0xF0,0xE7,0xB1,0x1D,0x1A,0x79,0x55,0x77,0x08,0xAA,0x92,0x63,0x75,
0x3B,0xBE,0xDB,0xD6,0xCA,0xB4,0x5E,0xBF,0x5F,0xF7,0x2B,0xA9,0x34,0x78,0xCE,0x31,
0x6F,0x56,0xC7,0xF6,0xBA,0x8E,0xE9,0x24,0xAA,0x99,0xDC,0xF6,0x41,0x04,0x2C,0x45,
0x7C,0xD3,0x3F,0xB5,0x7B,0x58,0xC4,0x55,0x5E,0x15,0x7D,0x91,0x55,0x03,0x04,0xED,
0xCB,0xAD,0xD6,0xCD,0x37,0x11,0xAE,0x76,0x6D,0xB7,0xD5,0x59,0xB5,0x23,0x4E,0xF3,
0x0C,0xA6,0x39,0x25,0xC7,0x6D,0x7A,0xAF,0x89,0xD5,0x58,0x13,0x23,0x6B,0x13,0x97,
0x7D,0x92,0x49,0x51,0x59,0x22,0xF1,0xE5,0x1A,0xAA,0xD5,0x5F,0xA2,0x2A,0xF8,0x26,
0x04,0x6F,0x47,0xA7,0x28,0xBE,0x00,0xE6,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x27,0xD4,
0x9F,0xC7,0x4E,0xED,0x7B,0x5E,0xDF,0xFE,0xCE,0xB2,0x0F,0xEB,0xFF,0x00,0x06,0xD4,
0x11,0xB3,0xA3,0x46,0x92,0x69,0x85,0xB7,0xA0,0x4E,0x9D,0xE2,0xD6,0xDC,0x0E,0xD5,
0x05,0xBB,0x28,0xC0,0x6A,0xAA,0xAF,0x14,0x70,0xD3,0x35,0x19,0x74,0x9A,0xA2,0x29,
0xD2,0x79,0x27,0x4E,0x3F,0x78,0xE7,0xA7,0x85,0x57,0x73,0xE1,0x11,0x3D,0x91,0x10,
0x0D,0x69,0xE4,0xB9,0x66,0x59,0x17,0xC1,0xCB,0xA5,0x14,0x8F,0xBA,0xD6,0x32,0xC3,
0x5D,0x9B,0x47,0x6D,0xC8,0x65,0x81,0xEE,0x6F,0x6D,0xAB,0xEF,0xDA,0xC7,0x39,0xAE,
0x54,0xF6,0x67,0xAA,0xC8,0x53,0xF5,0x54,0x37,0x49,0xBD,0x0C,0x5B,0x6E,0xCC,0xE9,
0x9F,0xA9,0x58,0x85,0xFE,0xD9,0x65,0x6E,0x99,0xD3,0x69,0xF5,0x7B,0x1B,0x4C,0xC4,
0x67,0xD8,0x61,0xA0,0x8E,0x81,0xEB,0x0A,0xC6,0x9F,0x85,0x11,0xAD,0x6C,0x6B,0x1A,
0xA7,0xB3,0x91,0xAA,0x9E,0x78,0x03,0x52,0x3B,0x82,0x8F,0x2C,0xB9,0xFC,0x1B,0xBA,
0x59,0x4F,0xA9,0x14,0xB3,0xFD,0xA2,0x4A,0x9B,0x34,0x51,0xC7,0x56,0xAE,0xEE,0x7D,
0x17,0xDF,0x92,0x25,0x37,0xBF,0x9E,0xD5,0x83,0xB3,0xB7,0x8F,0x1D,0xBD,0xBC,0x78,
0xE0,0x97,0x7F,0x12,0xC6,0x95,0xE9,0xC6,0x19,0xD0,0x2B,0x30,0xC2,0xF1,0x3C,0x2A,
0xD9,0x6C,0xB4,0x62,0xCB,0x8F,0xB6,0xCF,0x6C,0xA0,0x81,0xB1,0x41,0x6C,0x46,0x57,
0x53,0x44,0xD4,0x85,0x88,0x9C,0x31,0x12,0x37,0xB9,0xBE,0x3F,0x9A,0xE7,0x27,0xD5,
0x40,0xEE,0xF5,0xBD,0xD2,0x2D,0x33,0xC3,0xFE,0x1C,0x5C,0xE3,0x02,0xC5,0x30,0x5B,
0x55,0xB6,0xC9,0x8E,0x62,0xB6,0x39,0x2D,0x76,0xBA,0x1A,0x76,0xC7,0x05,0x03,0x99,
0x5B,0x43,0xDA,0xE8,0xD8,0x89,0xC3,0x57,0xE7,0x77,0x9F,0x75,0xEE,0x77,0x2A,0xBC,
0xAF,0x38,0x13,0xAB,0x2D,0x76,0xE0,0x32,0x7D,0x69,0xE9,0x9B,0x8E,0x69,0x95,0xD3,
0x0C,0x4A,0x9B,0x9F,0x75,0x6D,0x04,0xBA,0x9B,0x1D,0x44,0xD6,0x19,0xAF,0xAD,0xB7,
0xD0,0x7D,0x91,0xD5,0x4C,0x85,0x52,0x47,0x3F,0x97,0xAF,0xA7,0xDB,0xE7,0xBD,0xE9,
0xF4,0x55,0x03,0x2F,0xEE,0x8F,0xA7,0x97,0x5B,0x1D,0xF7,0xDF,0x74,0xB6,0x0D,0xC9,
0x6A,0xE6,0xD7,0x2D,0x74,0x5A,0x69,0x9B,0x5B,0xB3,0x0A,0x3B,0xD6,0x0B,0x6B,0xBE,
0x47,0x77,0xA6,0x92,0x99,0xFF,0x00,0x3B,0x23,0x7C,0xCA,0xE6,0xF6,0xBD,0xAB,0xE5,
0xAB,0xDA,0x8E,0x73,0x19,0xCA,0xA7,0x06,0xD1,0x20,0xF2,0x9C,0xAF,0x9E,0x55,0x57,
0x90,0x3F,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5A,0x9A,0xE5,0xA4,0xB6,0x1D,0x7A,0xD1,
0x7C,0xBF,0x43,0xB2,0xAA,0xDA,0xBA,0x6B,0x5E,0x67,0x65,0xAC,0xB1,0x56,0x54,0x50,
0x39,0x1B,0x3C,0x50,0xD5,0x40,0xF8,0x24,0x74,0x6A,0xE4,0x54,0x47,0xA3,0x64,0x55,
0x45,0x54,0x54,0xE7,0x8E,0x51,0x4B,0x4B,0x6C,0x7B,0x46,0xC0,0x76,0xB3,0xB4,0x7C,
0x5F,0x67,0x58,0x4D,0xF2,0xEF,0x5D,0x8F,0x62,0xB6,0x34,0xB1,0x53,0xDC,0x2E,0x92,
0x31,0xD5,0x93,0x45,0xDA,0xE6,0xAB,0xDE,0xE6,0x35,0xAC,0xEF,0x5E,0xF5,0xF6,0x6A,
0x27,0xB7,0x80,0x31,0xE6,0x80,0x74,0xA2,0xDA,0xC6,0x87,0x74,0xEB,0x8F,0xA6,0x35,
0xDA,0xDB,0x72,0xCD,0xB4,0xD1,0xD4,0xB5,0x94,0xB5,0x30,0x65,0xB2,0xB1,0xD5,0x35,
0x6D,0xA9,0xAA,0x7D,0x4B,0x95,0x64,0x85,0xB1,0xA3,0x1E,0xC9,0x24,0xE5,0x8E,0x62,
0x35,0xCD,0x56,0x31,0x51,0x79,0x4E,0x48,0xFB,0x41,0xF0,0xDD,0x68,0x45,0x56,0x3D,
0x6E,0xD1,0x9D,0x42,0xDF,0x2E,0xE4,0x72,0xDD,0x1D,0xB4,0x4A,0xC7,0x52,0xE8,0xC5,
0xF7,0x32,0xFF,0x00,0x01,0x7A,0x4C,0x77,0x74,0x74,0xEF,0x48,0xE2,0x6C,0x8E,0x85,
0xAB,0xEC,0xD4,0x72,0x71,0xE3,0x85,0x4E,0x39,0x02,0x4E,0x6F,0x67,0xA7,0x46,0x87,
0x6F,0x7F,0x68,0xED,0xD9,0x76,0x65,0x57,0x73,0xC5,0xF0,0xE8,0x26,0xB6,0xC9,0x4B,
0x1E,0x1E,0xB1,0x53,0xC9,0x47,0x1D,0x0C,0xAC,0x7C,0x10,0xC6,0x8F,0x63,0xD8,0xD8,
0xD1,0x23,0x6B,0x38,0xED,0xF0,0xDF,0x6E,0x38,0x3D,0x1D,0xFB,0xEC,0x57,0x4B,0xFA,
0x85,0x6D,0x33,0x21,0xD9,0xEE,0xAE,0x64,0x77,0xCB,0x5E,0x3D,0x91,0x7D,0x91,0x66,
0xAF,0xC7,0xA5,0x8E,0x3A,0xC8,0x96,0x9E,0x78,0xE7,0x67,0x6B,0xA4,0x63,0xD9,0xE5,
0xD1,0x22,0x2F,0x2D,0x5E,0x51,0x57,0xD8,0x0E,0xC6,0xEF,0xB6,0x45,0xA6,0xBB,0xCB,
0xD9,0x96,0x45,0xB2,0x4D,0x42,0xC8,0xAF,0x76,0xDC,0x6B,0x24,0xB6,0xD3,0xDB,0x26,
0xB8,0xD9,0xA4,0x8D,0xB5,0xB0,0xB2,0x09,0x21,0x91,0x8E,0x6B,0x9E,0xC7,0x33,0xBB,
0xBA,0x06,0x73,0xCB,0x55,0x15,0x15,0x7C,0x79,0xF1,0xE0,0x6E,0x8F,0xA6,0x56,0xD7,
0x77,0x8B,0xB5,0x8B,0x0E,0xD2,0xB5,0xCE,0xC7,0x72,0xAE,0xB1,0xE2,0xB1,0xD1,0xAD,
0x92,0xF9,0x43,0x58,0xB4,0xD7,0x7B,0x3D,0x45,0x2C,0x49,0x14,0x35,0x70,0x54,0xB5,
0x3E,0x49,0x91,0x89,0xC2,0xFC,0xAA,0xD5,0xEE,0x5E,0x5A,0xA9,0xC0,0x18,0xA7,0x48,
0xFA,0x30,0x4D,0x84,0x6A,0x1E,0x33,0x9B,0x6A,0xB7,0x53,0x1D,0xD1,0x6A,0x5D,0x0E,
0x1F,0x70,0xA7,0xB9,0xDB,0x71,0x5C,0xBF,0x34,0x46,0xDB,0x24,0x9A,0x07,0xA3,0xE2,
0x5A,0x96,0x41,0x13,0x1F,0x50,0x8D,0x73,0x53,0xE5,0x7B,0xB8,0x77,0xB2,0xA2,0xA7,
0x82,0x6D,0xC6,0xD5,0x44,0xF2,0xA0,0x72,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x9D,0x45,0x44,0x34,
0xD1,0x3A,0x69,0xA4,0x46,0x31,0xA9,0xCB,0x9C,0xE5,0xE1,0x11,0x3F,0x35,0x52,0xC5,
0xB7,0x6E,0x8B,0x6D,0xD7,0x79,0xAA,0x29,0xAD,0x3B,0x80,0xC2,0x2A,0xA4,0xA4,0x93,
0xD2,0x9E,0x3A,0x6B,0xFD,0x23,0xDD,0x0B,0xFF,0x00,0xA2,0xE4,0x49,0x3C,0x2F,0xF0,
0x5F,0x20,0x5C,0xF9,0x2E,0x71,0x88,0xE1,0x98,0xFC,0xF9,0x6E,0x5F,0x94,0x5B,0xAD,
0x56,0xAA,0x56,0x24,0x93,0x5C,0xEE,0x75,0x51,0xD3,0xD3,0xC2,0xD5,0xF6,0x73,0xA5,
0x7A,0xA3,0x51,0x3F,0x8A,0xA9,0xD7,0xC0,0xB5,0x3B,0x4E,0xF5,0x4A,0xC9,0xFB,0x49,
0xA6,0x79,0xED,0x97,0x22,0xB7,0x77,0xAC,0x7F,0x78,0x58,0x6B,0xE2,0xAC,0x83,0xB9,
0x3D,0xDB,0xEA,0x46,0xE7,0x37,0x94,0xFC,0xB9,0xE4,0x0E,0x37,0x4D,0x54,0xD3,0x6B,
0x2C,0x17,0x9A,0xAB,0xC6,0xA0,0x59,0x29,0x22,0xC7,0x51,0x8B,0x75,0x92,0xA6,0xE1,
0x0C,0x6D,0xB6,0x23,0xD3,0xB9,0xBE,0xBA,0xAB,0x91,0x22,0xE5,0x17,0x94,0xEF,0xE3,
0x94,0xF6,0x3B,0x18,0x5E,0x7D,0x85,0x6A,0x3D,0x86,0x1C,0xAF,0x4F,0xB2,0xEB,0x65,
0xF6,0xD5,0x53,0xCF,0xA3,0x73,0xB3,0x55,0xC7,0x55,0x4F,0x2F,0x0B,0xC2,0xF6,0xC9,
0x1A,0xAB,0x57,0x85,0xFC,0x94,0x0F,0x37,0x50,0xB5,0xC7,0x47,0x34,0x96,0xA2,0x96,
0x97,0x54,0xF5,0x63,0x19,0xC6,0xA4,0xAE,0x55,0x4A,0x68,0xF2,0x0B,0xB4,0x14,0x4E,
0xA8,0xFF,0x00,0x41,0x25,0x73,0x7B,0xBF,0xAB,0x92,0xE0,0x92,0xF5,0x6B,0x8A,0xD2,
0xB7,0xD9,0x6E,0x50,0x36,0x89,0x22,0x59,0xD6,0xAD,0xD2,0xB5,0x22,0x48,0xF8,0xEE,
0xEF,0xEF,0xF6,0xED,0xE3,0xCF,0x3C,0xF1,0xC7,0x90,0x2D,0xF5,0xD7,0x0D,0x1D,0x4B,
0xAD,0x92,0xC2,0xBA,0xAD,0x8D,0x25,0x76,0x4B,0x12,0x4F,0x68,0xA3,0xFB,0xD6,0x0F,
0x56,0xEB,0x1A,0xFF,0x00,0x3E,0x9D,0x9D,0xFC,0xCC,0xDF,0xE2,0xC4,0x54,0x3F,0x2C,
0xC3,0x5F,0x74,0x47,0x4F,0x2F,0xF0,0x62,0x79,0xF6,0xB0,0xE2,0xD6,0x3B,0xAD,0x57,
0x0B,0x0D,0xB2,0xF1,0x78,0xA7,0xA5,0xA8,0x97,0x9F,0x6E,0xD8,0xA4,0x7A,0x39,0x7F,
0xD4,0x05,0xA7,0xBD,0x8D,0xD7,0xE2,0xDB,0x32,0xDA,0xC6,0x73,0xB9,0x8C,0x8A,0x82,
0x9E,0xE4,0xCC,0x3E,0xC7,0x57,0x77,0x82,0xC9,0x2D,0xC2,0x3A,0x37,0xDD,0x9F,0x04,
0x2E,0x95,0x29,0xE3,0x91,0xC8,0xBF,0x33,0xFB,0x78,0x4E,0x1A,0xE5,0xFA,0xF0,0xA7,
0xE1,0xB2,0x7D,0xE2,0x60,0x7B,0xCD,0xDB,0x96,0x0F,0xAE,0xD8,0xDB,0xE8,0x2D,0xD5,
0x99,0x86,0x3D,0x49,0x7E,0x9B,0x17,0x8E,0xE9,0x0D,0x65,0x4D,0xA9,0x27,0x8D,0xAF,
0x58,0xA4,0x56,0x70,0xAB,0xDA,0xAE,0x46,0xAB,0x95,0x8D,0xF3,0xF4,0x45,0xF0,0x05,
0xE1,0x93,0x6E,0x13,0x42,0xB0,0xBC,0xB6,0x1C,0x07,0x31,0xD6,0x7C,0x4E,0xD3,0x7D,
0xA8,0xED,0xF4,0xAC,0xB7,0x3B,0xCD,0x35,0x3D,0x5C,0x9D,0xDF,0x87,0xB6,0x17,0xBD,
0x1E,0xBC,0xFD,0x3C,0x79,0x2E,0x7B,0xBD,0xEE,0xD5,0x8F,0xDA,0x2A,0x6F,0xB7,0xEB,
0x95,0x3D,0x0D,0x15,0x1C,0x6E,0x9A,0xA2,0xAE,0xB2,0x56,0xC5,0x14,0x0C,0x6A,0x72,
0xE7,0xB9,0xEE,0x54,0x46,0xB5,0x11,0x39,0x55,0x55,0xE1,0x00,0xF0,0xD9,0xAC,0xBA,
0x4F,0x26,0x51,0x6C,0xC1,0xD9,0xA9,0xD8,0xEA,0xDE,0xAF,0x54,0xC9,0x5B,0x6F,0xB3,
0xA5,0xCE,0x05,0xAA,0xAF,0x81,0x5A,0xAE,0xF5,0x62,0x8B,0xBB,0xBE,0x46,0x70,0x8A,
0xBD,0xCD,0x45,0x4E,0x13,0x9E,0x4B,0x99,0x8F,0xEE,0x4E,0x40,0xE4,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x45,0xF6,
0x03,0x5D,0x9F,0x13,0x7E,0x61,0x7F,0xC4,0x3A,0x69,0x32,0x4F,0xDA,0x4B,0x95,0xBB,
0x10,0xB9,0x66,0xD6,0x1B,0x7E,0x6A,0xDB,0x2D,0x57,0xA1,0x5B,0x57,0x62,0x96,0xA1,
0x52,0xA6,0x08,0x78,0x54,0x7B,0xDC,0xF7,0x24,0x48,0xAC,0x67,0x95,0x6F,0x77,0x28,
0xAD,0xEE,0x20,0xF6,0xE4,0x34,0x03,0xA2,0x76,0xF1,0xF7,0xAB,0xB4,0xED,0x25,0xE9,
0x61,0xA2,0x3A,0x7D,0x9A,0x54,0xBB,0x26,0x6C,0xF9,0xC5,0xBF,0x09,0xB4,0xCC,0xB6,
0xC8,0xB1,0x76,0xC4,0x8B,0x33,0xEE,0x9C,0xB5,0xA8,0xD9,0xBC,0x7C,0x8E,0x91,0x52,
0x54,0x72,0x39,0x1D,0xE5,0x58,0x8A,0x19,0x33,0xA9,0x46,0xA5,0x60,0xDA,0xC9,0xD6,
0xC6,0xC9,0xB4,0x8D,0xC0,0xED,0x47,0x55,0x35,0x8B,0x46,0xF4,0x5F,0x4F,0xA9,0xEF,
0x94,0x1A,0x3B,0xA5,0x16,0x65,0xB9,0xC3,0x59,0x74,0xA8,0x7B,0x18,0xCA,0xDA,0xEA,
0x54,0x9A,0x24,0x7D,0x3C,0x30,0xBD,0x91,0xB5,0x1C,0xAA,0x88,0xE6,0xB5,0x38,0xE1,
0xEF,0x45,0xF6,0x76,0x61,0x82,0x5E,0x74,0xFF,0x00,0xAC,0x96,0x03,0xA9,0xDB,0x05,
0xE9,0x95,0xAE,0xBA,0x0F,0xA4,0x39,0x9E,0x3D,0x71,0xB3,0x6A,0x5D,0x9B,0x32,0xC5,
0x7E,0xE3,0xB0,0xAC,0xD1,0x45,0x24,0xD4,0x35,0x91,0x44,0xD9,0xA4,0x89,0x92,0xA4,
0x8C,0x63,0x15,0x5B,0xDA,0xBE,0x78,0x6A,0x7E,0xF1,0xEA,0xA1,0xD7,0xDB,0xD6,0xC2,
0x74,0x33,0x7D,0xBD,0x78,0x77,0xAD,0x6E,0xDC,0xDD,0x3D,0xC3,0x25,0xC3,0xB0,0xCB,
0xB6,0x39,0x70,0x8F,0x4E,0xAA,0x2A,0x9F,0x1D,0x96,0xEB,0x5D,0x2D,0xB3,0xB2,0x3A,
0xAA,0xC8,0x58,0xA8,0xB3,0xBA,0x06,0x32,0x44,0x8D,0xAE,0x5E,0xD4,0x59,0xDE,0xAA,
0x8B,0xE0,0xC8,0x3D,0x31,0x74,0xA7,0x0A,0xD8,0x8F,0x5B,0xAD,0xD2,0x6C,0xB3,0x6F,
0x74,0xD5,0x56,0x6D,0x2B,0x9F,0x0D,0xB3,0xE7,0x54,0xB8,0x5B,0x27,0x7C,0x94,0x96,
0xBA,0xD7,0x7A,0x4D,0x97,0xEC,0xED,0x72,0xAA,0xB1,0x1E,0x93,0x3F,0xDB,0xE8,0x8C,
0x6F,0x94,0x63,0x78,0x08,0x89,0xD3,0xB3,0x51,0x76,0xD5,0xBC,0x1C,0x5F,0x3F,0xDE,
0x7E,0xFE,0x3A,0x4E,0xEB,0xFE,0xE5,0xF3,0xED,0x4C,0xC9,0x2E,0x09,0xFB,0x57,0x69,
0xC2,0x5B,0x7E,0xB2,0x59,0x6D,0xD1,0x48,0xB1,0xD3,0xDB,0xA8,0x1E,0xFA,0x96,0x24,
0x3E,0x8A,0x77,0x22,0xAB,0x1A,0x8E,0x6A,0xF0,0x9C,0xFC,0xBC,0x92,0x87,0xA6,0xBE,
0x21,0xB8,0x6D,0x2C,0xE9,0x75,0xBC,0x0D,0x11,0xD4,0x6D,0x14,0xD4,0xEC,0x27,0x4D,
0x31,0xE8,0xB2,0x49,0x34,0xCA,0xD5,0xAB,0x34,0x2E,0xA5,0xBA,0x53,0x58,0xEA,0x2D,
0x95,0x32,0x36,0x95,0x58,0xE7,0x39,0x55,0x90,0xB9,0x13,0xEA,0xA9,0xCC,0x8E,0x44,
0x55,0xF2,0x88,0x1F,0xBF,0xC3,0xF1,0xD2,0x73,0x69,0xF9,0x66,0xC8,0x34,0x4F,0x7D,
0xFA,0xF1,0x8D,0x55,0x6A,0x06,0xAA,0x4D,0x4F,0x49,0x76,0xB3,0x64,0xF9,0x05,0x65,
0x42,0xBB,0x18,0x86,0x8A,0x57,0xC5,0x43,0x45,0x47,0x13,0x24,0x46,0x32,0x18,0x5B,
0x12,0x3B,0x85,0x6A,0xF7,0xBD,0xEE,0x55,0xFA,0x22,0x59,0x9A,0x99,0x8E,0xFC,0x3F,
0x39,0x36,0x5B,0xA9,0xFA,0x69,0xA7,0x3D,0x3E,0x35,0x4B,0x72,0x39,0x35,0x45,0xD2,
0xBA,0x1C,0xB3,0x50,0x74,0xFF,0x00,0x0F,0xB8,0xE5,0x95,0x14,0x77,0x19,0x1C,0xE7,
0xCA,0x8D,0xBC,0x49,0x23,0x5A,0xC7,0xC7,0xDD,0xF2,0xFA,0x0F,0xED,0x44,0x6A,0x71,
0xCF,0x0A,0xA0,0x58,0x9B,0x77,0xD3,0xEC,0x1F,0x76,0x7F,0x09,0x7D,0xFF,0x00,0x28,
0xDC,0x8E,0x2F,0x16,0x67,0x75,0xD2,0x8B,0x16,0x5B,0x2E,0x2B,0x74,0xC9,0x3B,0xA5,
0xAB,0xB3,0xC9,0x4A,0xFA,0x86,0x53,0x3D,0x8E,0xEE,0xE5,0x1D,0x1B,0x15,0x18,0xD4,
0x5E,0x51,0x1A,0xC6,0xA7,0x1C,0x22,0x19,0x93,0x6C,0x5A,0x5B,0xB7,0x8E,0x9A,0x9D,
0x01,0xE3,0xEA,0x63,0xB6,0x4D,0xBF,0xE3,0x56,0x2D,0x60,0xA9,0xD1,0x5A,0x69,0xEA,
0x33,0x0A,0x5A,0x67,0x2D,0x4D,0x65,0x4D,0x44,0x50,0x2F,0xA9,0x2A,0xAB,0x95,0x1C,
0x9F,0x68,0xF4,0xA5,0x72,0x27,0x08,0xAB,0x12,0x7D,0x00,0xBB,0x7A,0x7D,0x74,0x15,
0xE9,0xD3,0xAD,0x1D,0x39,0xB0,0x9C,0xD7,0x73,0x9A,0x23,0x49,0xA8,0x39,0xF6,0xAD,
0x62,0xF4,0x99,0x16,0x47,0xA9,0x17,0xFA,0xB9,0xE7,0xBD,0x4D,0x57,0x70,0x81,0xB5,
0x0E,0x92,0x2A,0xA5,0x7A,0xBA,0x27,0x47,0xEB,0x22,0x35,0x5B,0xC7,0x3D,0x9C,0xBB,
0xB9,0x55,0x79,0xC2,0xFB,0x41,0xD5,0xDD,0x50,0xCC,0xFE,0x1C,0x0D,0xE1,0x68,0x56,
0xAA,0xE7,0xB5,0xD9,0x45,0x4E,0x88,0x37,0x31,0xC0,0xED,0xF7,0xEB,0x93,0xD6,0x49,
0x6A,0x68,0x29,0x69,0x11,0xD0,0x23,0xA4,0x55,0x5E,0xEE,0xCF,0x51,0xED,0x4F,0x3E,
0x18,0x8C,0x6A,0x78,0x6A,0x01,0x9F,0xBA,0x1C,0xF4,0x9D,0xDA,0x6D,0x8B,0x6A,0x3A,
0x19,0xBE,0xBD,0x44,0xC5,0x67,0xCD,0x75,0x9A,0xE7,0x60,0xB7,0xE4,0x51,0x6A,0x16,
0x41,0x57,0x3A,0xD5,0x5B,0x1B,0x25,0x0B,0x60,0xA7,0xA3,0xA7,0x8D,0xAF,0x48,0xD9,
0x4F,0x4F,0x4A,0xAD,0x85,0xAC,0x56,0xAA,0x2F,0x6F,0x77,0x85,0xE1,0x1B,0xB2,0xE8,
0xA3,0xF4,0xDB,0xDA,0x9E,0xC8,0x07,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x4E,0xF9,0x7D,0xB3,0xE3,0x56,0xB9,0xAF,
0x79,0x05,0xD6,0x9A,0x86,0x8E,0x99,0xBD,0xF2,0xD5,0xD6,0x4A,0xD8,0xA2,0x89,0x3F,
0x37,0x3D,0xCA,0x88,0x89,0xFC,0x54,0xF1,0xAB,0xB5,0x77,0x4B,0xED,0x59,0x45,0xBF,
0x07,0xB9,0xEA,0x35,0x86,0x9A,0xF5,0x76,0x62,0x49,0x45,0x67,0x9E,0xE5,0x0B,0x2A,
0xAB,0x1A,0xBE,0xCE,0x8A,0x15,0x77,0x7B,0xD3,0xF8,0xB5,0x14,0x0E,0x57,0xFD,0x59,
0xD3,0x3C,0x57,0x28,0xB7,0x61,0x19,0x36,0xA1,0x58,0xED,0xD7,0x9B,0xC7,0xFD,0xA1,
0x68,0xB8,0x5C,0x61,0x82,0xAA,0xB7,0xCF,0x1F,0xBA,0x89,0xCE,0x47,0xBF,0xCF,0x8F,
0x95,0x14,0xF7,0xD6,0x54,0xED,0xEE,0x4E,0x7F,0x44,0x02,0xD8,0xC4,0xB5,0xBB,0x48,
0x33,0xDB,0xED,0x5E,0x2F,0x83,0xEA,0x9E,0x37,0x79,0xB9,0x5B,0xFF,0x00,0xED,0xAB,
0x75,0xA6,0xEB,0x05,0x4C,0xF4,0xDC,0x7B,0xF7,0xC6,0xC7,0x2B,0x9B,0xFD,0x68,0x7B,
0x55,0x99,0x3D,0x86,0x82,0xED,0x47,0x61,0xAE,0xBC,0xD2,0xC3,0x5D,0x70,0x47,0xAD,
0x2D,0x14,0xB3,0xB5,0xB3,0x54,0xA3,0x13,0x97,0xF6,0x31,0x57,0xB9,0xFD,0xA9,0xE5,
0x78,0x45,0xE3,0xEA,0x07,0x9B,0x88,0x6A,0xDE,0x97,0xE7,0xF7,0x6A,0xFB,0x0E,0x0D,
0xA8,0xD6,0x1B,0xCD,0x6D,0xA9,0xFD,0x95,0xB4,0x76,0x8B,0x8C,0x35,0x32,0xD1,0xBB,
0xF2,0x95,0x8C,0x72,0xAB,0x17,0xFD,0x24,0x43,0xD3,0xFD,0xA9,0xC7,0x7F,0x68,0x7F,
0x64,0xBE,0xFE,0xA2,0xFB,0xD3,0xD0,0xFB,0x4F,0xDD,0xBF,0x68,0x67,0xDA,0x3D,0x2E,
0x78,0xF5,0x3D,0x3E,0x7B,0xBB,0x79,0xF1,0xDD,0xC7,0x1C,0x81,0x4A,0x9C,0xA7,0x1E,
0xA3,0xBF,0x53,0x62,0xF5,0x77,0xDA,0x38,0xAE,0x35,0x8C,0x74,0x90,0x50,0x49,0x50,
0xC6,0xCF,0x3B,0x5B,0xF8,0x9C,0xD8,0xD5,0x7B,0x9C,0x89,0xF5,0x54,0x4F,0x07,0xA2,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x28,0xEF,0x28,0x06,0xB3,
0xFE,0x24,0x5B,0x83,0xF2,0x3C,0x27,0x6E,0x5A,0x1B,0xA7,0xF9,0x4C,0xF8,0xEE,0xA8,
0xE5,0x3A,0xBB,0x6A,0xA8,0xC1,0xF2,0xAA,0xA9,0xE3,0x8E,0xD5,0x62,0xAF,0xA7,0xE7,
0xBA,0xAE,0xB1,0xB2,0x31,0xED,0x95,0x8C,0x65,0x47,0xCB,0x17,0x1C,0xB9,0xEA,0x8A,
0x8A,0xA8,0xD5,0x6B,0xB1,0xF6,0xF0,0xF5,0x3F,0xAB,0x2F,0x45,0x9D,0x1D,0x66,0xED,
0xB3,0x7D,0xD3,0x68,0x8E,0xAC,0x63,0x29,0x7B,0xA2,0xA1,0xBB,0x60,0xF1,0x69,0xF4,
0x78,0xAD,0xD2,0xFD,0xF6,0x89,0x92,0x35,0xFB,0x2C,0xD4,0xD2,0x2F,0xA9,0x50,0x9D,
0xEA,0xFF,0x00,0x28,0xA8,0x8D,0x6B,0x9C,0xA8,0xEE,0x15,0xAA,0x19,0xEF,0x7C,0x3D,
0x3D,0xB7,0x5F,0x92,0xEE,0xFF,0x00,0x0F,0xEA,0x93,0xD3,0x8F,0x50,0x31,0x4C,0x7B,
0x55,0xAD,0xB8,0xEF,0xEC,0xD5,0xFF,0x00,0x0C,0xD4,0x98,0x66,0x4B,0x3E,0x53,0x6B,
0x73,0xFD,0x66,0xC3,0x34,0x90,0x73,0x24,0x33,0x46,0xE5,0xE3,0xB9,0x13,0xCF,0x64,
0x7F,0x33,0x7B,0x38,0x7E,0x46,0xDA,0x9A,0x75,0x8D,0xCA,0xB5,0x92,0x9F,0x21,0xDE,
0x8D,0x2E,0x80,0xE2,0x98,0x15,0x25,0x1C,0xCC,0x7E,0x39,0xA7,0x0F,0xB8,0xDC,0xEE,
0x97,0x2A,0x97,0x35,0x12,0x37,0xBA,0xAA,0xA1,0x1A,0xC8,0xA3,0x6A,0xF2,0xBC,0x35,
0xAA,0xAB,0xEC,0xBE,0xFC,0xA0,0x79,0xFB,0x2E,0xD8,0x96,0xB1,0x6D,0xEF,0xA9,0x5E,
0xEA,0xB7,0x75,0x9B,0xDE,0x2C,0x33,0x63,0x3A,0xD5,0x53,0x62,0x9A,0xC3,0x4D,0x6E,
0xA8,0x92,0x4A,0xC8,0x5B,0x45,0x48,0xE8,0xA6,0xFB,0x43,0x1C,0xC6,0xB5,0x8A,0xAE,
0x72,0x76,0xF6,0xB9,0xDC,0xA7,0x95,0xE3,0xD8,0x69,0x3E,0xC4,0xB5,0x87,0x08,0xEB,
0x31,0xAB,0x1B,0xFC,0xBC,0x5E,0x2C,0x0F,0xC2,0x73,0x7C,0x0A,0xD9,0x8D,0x50,0x51,
0x41,0x51,0x23,0xAE,0x0C,0xAA,0xA7,0x92,0x17,0x48,0xB2,0x44,0xAC,0x46,0x24,0x7C,
0x42,0xBC,0x2A,0x3D,0x55,0x7B,0x93,0xC2,0x79,0x03,0x04,0x69,0x16,0xC0,0xFA,0xB0,
0xF4,0xC1,0xCD,0xF3,0x6D,0x3F,0xE9,0xBB,0x7D,0xD1,0x7C,0xFB,0x45,0x72,0xFB,0xF5,
0x56,0x47,0x6C,0xC4,0x35,0x66,0xAA,0xBA,0xDD,0x71,0xC4,0xEA,0x2A,0x15,0x1D,0x2C,
0x10,0xCF,0x4E,0xC7,0x36,0x58,0x39,0x44,0xE3,0xBB,0xCF,0xCA,0x8B,0xC3,0x5C,0xAE,
0x73,0xA4,0xC6,0x19,0xA4,0x1B,0xFF,0x00,0xD5,0x5D,0x92,0xEA,0x8E,0x99,0x6F,0x3F,
0x2E,0xD2,0xE9,0xF5,0x07,0x39,0xB5,0xDD,0x6D,0xF6,0xAA,0x3D,0x3A,0xA7,0xAB,0xA7,
0xB3,0x59,0xE1,0xA9,0xA0,0x58,0x21,0x81,0xF3,0x4F,0xCC,0xB3,0x2A,0x4A,0xE7,0x39,
0xD2,0xAB,0x53,0xC3,0xB8,0x44,0x5E,0x00,0xF5,0x7A,0x5B,0xED,0x5B,0x3F,0xD9,0xDF,
0x4E,0xDD,0x2F,0xDA,0x86,0xAF,0x5C,0x2D,0x75,0x59,0x06,0x21,0x64,0x5B,0x75,0xC6,
0x6B,0x15,0x43,0xE5,0xA6,0x73,0xD6,0x59,0x5E,0xBE,0x9C,0x8E,0x6B,0x1C,0xA9,0xC4,
0x88,0x9C,0xAB,0x53,0xCA,0x10,0xFB,0x68,0x1D,0x3C,0x7A,0xC9,0x74,0xFA,0xD3,0x8B,
0xF6,0xC5,0x76,0xBD,0xA9,0x3A,0x12,0xBA,0x59,0x71,0xBF,0x56,0xD7,0x5A,0x35,0x5F,
0x22,0x8E,0xBA,0x5C,0x8A,0xC7,0x49,0x56,0xFE,0xE9,0x15,0xD6,0xC6,0xB5,0x20,0xA9,
0xA9,0x62,0x7E,0x0E,0xF9,0x11,0x9D,0xDC,0x77,0x2A,0xB1,0x11,0xA8,0x19,0x47,0x61,
0xBD,0x26,0x73,0xFD,0x10,0xE8,0xF3,0x97,0xF4,0xCA,0xD7,0x9C,0xF6,0xD7,0x3D,0x7E,
0x57,0x0E,0x4B,0x6D,0x7E,0x41,0x63,0x73,0xAA,0x23,0x8E,0x0B,0x8C,0xB3,0x7A,0x33,
0xAB,0x5C,0xD6,0x73,0x22,0x36,0x46,0x3D,0xCC,0x44,0xE1,0x1D,0xCA,0x22,0xAF,0xB9,
0xE2,0xEC,0x53,0x60,0xFD,0x43,0x61,0xDA,0x1D,0xDB,0xA6,0x4F,0x51,0x86,0x68,0xF5,
0xC7,0x45,0xE8,0x70,0x6A,0x8C,0x2E,0xDB,0x7D,0xD3,0xDA,0xAA,0xD7,0x5F,0xAE,0x2D,
0x73,0x9B,0x14,0x12,0xC8,0x93,0x35,0xB1,0x44,0x91,0x53,0xF7,0x70,0xA8,0xDE,0xE5,
0x91,0x23,0x55,0xE7,0x87,0x72,0x16,0x6E,0x88,0xED,0x4F,0xE2,0x20,0xD9,0xD6,0x84,
0x52,0x6C,0x7B,0x41,0xB5,0x73,0x6E,0xB9,0x46,0x21,0x8F,0xC2,0xB6,0xAC,0x6B,0x55,
0x73,0x0F,0xBC,0x60,0xBD,0xDA,0x6D,0xFE,0x5B,0x12,0x3E,0x89,0x8C,0x74,0x32,0x49,
0x0B,0x38,0xEC,0x45,0xEF,0x4F,0x0D,0x45,0x57,0xA2,0x19,0x6F,0x09,0xE9,0x09,0x36,
0xDF,0x3A,0x31,0xEA,0x2F,0x4E,0x2D,0x1C,0xCE,0xE9,0xEF,0x99,0x96,0x77,0x8E,0xDE,
0x59,0x71,0xCC,0xB2,0x05,0x7D,0x34,0x77,0xAB,0xDD,0xC2,0x27,0x36,0x4A,0xA9,0xBB,
0x7B,0xDC,0xC8,0xF9,0xF4,0xD8,0x9F,0x89,0xC8,0xC8,0xDB,0xCF,0x72,0xF2,0xAA,0x12,
0x33,0xA7,0xFE,0x84,0xE6,0x1B,0x60,0xD9,0x26,0x93,0xED,0xD3,0x50,0x6B,0x68,0x2A,
0x2F,0x98,0x46,0x27,0x6E,0xB2,0x57,0xCF,0x6B,0x91,0xD2,0x53,0x3E,0x7A,0x7A,0x76,
0x46,0xF5,0x8D,0xCE,0x6B,0x55,0x59,0xDC,0xD5,0xE1,0x55,0xA8,0xBC,0x7D,0x10,0xCC,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x10,0xB3,0xE2,0x22,0x4E,0x7A,0x2F,0x6B,0xFF,0x00,0xF0,0xB0,0x45,0xFF,0x00,
0x3D,0xA6,0x20,0xEE,0xED,0x3A,0x3A,0xED,0x06,0xC1,0xD0,0x82,0xF1,0xBC,0x2B,0xB5,
0xA6,0xF1,0x7E,0xD6,0xFA,0x5C,0x1A,0x83,0x3E,0xFE,0xEC,0x57,0x8B,0x9C,0xEF,0xBE,
0x7D,0xBD,0xB4,0xF4,0xF3,0xB6,0x36,0x48,0x8E,0xED,0x8E,0x9D,0x91,0xF1,0x0B,0x21,
0x6A,0x23,0x58,0xC6,0xB5,0x53,0xE7,0x4E,0xF0,0x3B,0xBA,0xB7,0xD2,0x6B,0x6B,0xFA,
0xA5,0xD0,0x8F,0x22,0xDF,0xA6,0xB7,0xB6,0xF9,0x9D,0x6B,0xD5,0xFF,0x00,0x4D,0x59,
0xA9,0x93,0x6B,0x1E,0x4B,0x71,0x9A,0x4B,0xD4,0x17,0x14,0xA1,0x6D,0x6C,0x51,0x42,
0xF6,0xB9,0x19,0x15,0x34,0x68,0x89,0x0B,0x62,0x6B,0x7B,0x7B,0x13,0x95,0xF9,0xBC,
0xA7,0xE1,0xD4,0x57,0x7C,0xDA,0xE9,0x92,0xF4,0x42,0xD9,0xC6,0x39,0x70,0xBF,0x66,
0x55,0x57,0x3D,0xC5,0x54,0xE3,0xD6,0x3C,0xC6,0xE3,0x84,0xA3,0xA5,0xBF,0x5D,0xE8,
0x7E,0xCC,0xD7,0x56,0x41,0x4A,0xD4,0x56,0xAB,0xEA,0x6A,0x9C,0x8D,0x44,0x6F,0x72,
0x77,0xAB,0x9C,0xC5,0x5E,0x1E,0xA0,0x62,0xED,0xE2,0xE9,0x9E,0x8C,0x5B,0x34,0xAF,
0x11,0xCB,0x7A,0x4B,0xF4,0x3D,0xDD,0x1E,0x90,0x6B,0x96,0x9C,0xDE,0xE8,0x2E,0x58,
0xD6,0x5C,0xDD,0x3B,0x9E,0xDF,0x1D,0x54,0x71,0xCA,0xD4,0xA8,0xA7,0xAF,0x9D,0xB5,
0x12,0x3E,0x76,0x49,0x17,0x3C,0xFA,0x8D,0x72,0xB9,0x53,0x85,0x54,0x6B,0x9C,0x8B,
0x22,0xBA,0xDD,0xE8,0xFB,0xF7,0x31,0xD5,0x7F,0x61,0xDA,0x2D,0x90,0xE6,0x19,0x16,
0x23,0x06,0x63,0x06,0x51,0x45,0x74,0xAB,0xC6,0x2A,0xFE,0xCB,0x70,0x8A,0x99,0xF4,
0x94,0xEE,0xAA,0xA5,0x64,0xED,0xF3,0x1F,0xAB,0x1A,0x3E,0x07,0x39,0xBE,0x51,0x92,
0x3B,0x80,0x3C,0xDD,0xED,0x6C,0x47,0x6C,0x5D,0x2E,0x7A,0x8A,0xEC,0xAB,0x5D,0xF6,
0x19,0xA6,0xD1,0x69,0xAD,0x66,0x5B,0x9E,0xB3,0x02,0xC8,0x2D,0x98,0xFD,0x44,0xC9,
0x4B,0x7B,0xB7,0x54,0xC6,0xC6,0xAB,0x67,0x63,0xDE,0xE4,0x7B,0xD1,0x15,0xFF,0x00,
0x32,0xF2,0xAE,0x55,0x6B,0x97,0x97,0x31,0xAA,0x99,0x35,0x8D,0xEC,0xF8,0xB3,0x1C,
0xC7,0x2A,0x7F,0xE0,0xF3,0xEE,0xBF,0x5F,0xF0,0xAA,0x01,0xE8,0x6E,0xE5,0x18,0xEF,
0x89,0x9B,0x69,0x2B,0xDA,0xD5,0x54,0xD3,0xFC,0x9B,0xCF,0xD5,0x3F,0x73,0x54,0x6C,
0xA9,0x3F,0x0A,0x01,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA2,
0xF9,0x40,0x31,0x6E,0xEC,0xB6,0x6D,0xB6,0x8D,0xF0,0x69,0x64,0x9A,0x31,0xBA,0x9D,
0x22,0xB5,0x66,0x58,0xDB,0xE6,0x6D,0x4B,0x28,0xAE,0x28,0xF6,0xC9,0x4D,0x33,0x51,
0x51,0xB3,0x43,0x33,0x15,0xB2,0x45,0x22,0x23,0x9C,0x9D,0xCC,0x72,0x2F,0x0E,0x54,
0xF2,0x8A,0xA8,0x60,0x9D,0x11,0xE8,0x45,0xD3,0x0B,0x41,0xB5,0x36,0xD3,0xAC,0x98,
0xCE,0xDE,0x6B,0x2F,0x19,0x16,0x3B,0x2B,0x67,0xB4,0x56,0xE6,0xB9,0x05,0xCA,0xFA,
0xCB,0x5C,0x8D,0x54,0x56,0x3E,0x08,0x6A,0xE6,0x7C,0x6C,0x7B,0x55,0x11,0x5A,0xEE,
0xDE,0x51,0x5A,0x8A,0x8A,0x8A,0x88,0xA0,0x65,0xCD,0xAE,0xEF,0xB3,0x45,0xB7,0x67,
0xAA,0x7A,0xB7,0xA3,0xDA,0x5F,0x6C,0xC8,0x22,0xBA,0xE8,0xBE,0x45,0xFB,0x33,0x7E,
0x92,0xEF,0x46,0xD8,0x61,0x9A,0xAB,0x87,0xAF,0x74,0x0E,0x6B,0xDC,0xAF,0x8F,0xF7,
0x6E,0xF2,0xE4,0x6A,0xFB,0x78,0xF2,0x66,0x8E,0xF6,0x37,0xF0,0x31,0x57,0xF4,0x45,
0x50,0x2B,0xDC,0xDE,0x3B,0x91,0x8B,0xCF,0xE4,0xBE,0xE7,0x1F,0x51,0xBF,0xF9,0xA7,
0x73,0xFC,0x11,0x40,0xC3,0x18,0x2E,0xFB,0xF4,0x5B,0x50,0xF7,0xBB,0x9C,0x6C,0x12,
0xC7,0x6A,0xC8,0x1B,0x9B,0xE9,0xFD,0x8E,0x8F,0x20,0xB9,0xD4,0x54,0x51,0xB5,0xB6,
0xF7,0xD3,0xD5,0x76,0x7A,0x6D,0x8E,0x54,0x7A,0xB9,0xCF,0x4F,0x55,0xBC,0xA2,0xB1,
0x13,0xDF,0x85,0x5E,0x0C,0xC3,0x74,0xAF,0xA1,0xB6,0x5B,0xA6,0xB8,0xDC,0x2A,0xA3,
0xA7,0xA7,0xA7,0x62,0xC9,0x2C,0xD3,0x2F,0x6B,0x63,0x63,0x53,0x97,0x39,0x57,0xE8,
0x88,0x88,0xAA,0xBC,0x81,0x05,0x3A,0x1D,0xEB,0xB6,0xBD,0x6F,0x42,0xDB,0xAD,0x7B,
0xF4,0xD4,0xAD,0x49,0xBF,0x57,0x60,0xDA,0x8B,0x9C,0x54,0xD1,0x69,0xE6,0x2D,0x5D,
0x3B,0x9D,0x45,0x6A,0xB2,0x5B,0xD5,0xD4,0xF1,0xCD,0x04,0x5C,0x22,0x31,0xD3,0xBD,
0x5D,0xDF,0xC7,0xE2,0x74,0x1C,0xFD,0x79,0x59,0xE2,0xB2,0xB3,0x85,0x77,0xA4,0xEF,
0xFD,0x95,0xF2,0x06,0x18,0xDB,0x1E,0xFB,0x74,0x5B,0x76,0x5A,0xB7,0xAB,0xBA,0x31,
0xA6,0x56,0xAC,0x82,0x1B,0xBE,0x8B,0x64,0x0D,0xC6,0xEF,0xD2,0x5D,0xA8,0xDB,0x0C,
0x12,0xD4,0xAB,0x5E,0xBC,0xD3,0xB9,0xAF,0x72,0xBD,0x9F,0xBB,0x72,0x72,0xE4,0x6A,
0xFB,0x78,0xF2,0x66,0x7F,0x51,0x88,0xBC,0x36,0x35,0x5F,0xD3,0xC8,0x15,0xEE,0x63,
0x93,0xB9,0xCD,0x5F,0xFF,0x00,0x57,0x82,0x9E,0xAB,0x78,0xE3,0xD3,0x5F,0xEA,0x45,
0x5E,0x40,0xE7,0x1B,0x9A,0xA9,0xCA,0x35,0x53,0xF8,0x2F,0x83,0x98,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x76,0xEA,
0xC5,0xB5,0x9D,0x47,0xDE,0xC7,0x4F,0x1D,0x53,0xDA,0xC6,0x91,0x57,0x5A,0xA9,0xB2,
0x4C,0xCA,0xD2,0xDA,0x3A,0x09,0xEF,0x93,0x3A,0x1A,0x46,0xC8,0xDA,0x88,0xA5,0xFD,
0xE3,0xDA,0xD7,0xB9,0xA8,0xA9,0x1A,0xA7,0x28,0xD5,0xF2,0xA8,0x5B,0x9B,0x8E,0xD9,
0x76,0xAB,0xEA,0xBF,0x47,0xCB,0xC6,0xC3,0xB1,0x8B,0xA5,0x91,0x99,0x95,0x76,0x9B,
0x41,0x89,0x47,0x57,0x57,0x3B,0xD9,0x41,0xF6,0xC8,0xE8,0xE2,0x81,0x5C,0xB2,0x23,
0x15,0xC9,0x1A,0xBE,0x35,0xE1,0xDD,0x9C,0xF0,0xA8,0xBC,0x00,0xBE,0xEC,0xB7,0x55,
0xEE,0x7D,0x18,0xE4,0xE9,0xFB,0x4F,0x77,0xB2,0x26,0x6C,0xED,0x23,0x6E,0x0A,0x95,
0xAE,0x9E,0x4F,0xBB,0xFE,0xDE,0x96,0xB4,0xA4,0xEF,0xF5,0x3B,0x3B,0xFD,0x1F,0x51,
0x39,0xEE,0xEC,0xE7,0xB7,0xCF,0x6F,0xD0,0xC3,0x9A,0x87,0xD1,0xA3,0x3C,0xD6,0x7E,
0x90,0xBA,0x27,0xB3,0x2B,0xEE,0xAA,0xDB,0xF1,0x2D,0x5D,0xD1,0x0A,0x5B,0x45,0xDB,
0x1C,0xCE,0x2D,0x0D,0x7D,0x5D,0x25,0xB6,0xF7,0x40,0xC5,0x44,0x77,0x96,0xB5,0xEF,
0x81,0xDD,0xCA,0xD5,0x5E,0xD4,0x54,0x5E,0xD7,0xF6,0xAF,0x6F,0x6A,0x87,0xA7,0x87,
0xDC,0xBE,0x23,0xFC,0x85,0xF6,0xCC,0x07,0x33,0xC7,0x36,0xA9,0x8E,0xC7,0x0C,0xD1,
0x47,0x73,0xCF,0xE9,0x2B,0x2E,0xD7,0x09,0x27,0x85,0xAA,0xDF,0x52,0x48,0x2D,0xDD,
0xAD,0x6A,0x48,0xF4,0x45,0xF9,0x5E,0xE4,0x6A,0x2B,0xBE,0x88,0x85,0xE3,0xBD,0x1D,
0x84,0x6B,0x36,0xE1,0x3A,0x9B,0x6D,0x53,0x78,0x78,0x45,0xEA,0xC1,0x0E,0x2F,0xA2,
0x93,0xDF,0x64,0xBF,0x52,0xDC,0x6A,0x24,0x65,0x6C,0xCD,0xAC,0xA6,0x64,0x70,0xFD,
0x9D,0x89,0x1B,0x9A,0xFE,0x1C,0xD5,0xEE,0xEE,0x73,0x78,0x4F,0xCC,0x0E,0xD7,0x52,
0xFD,0x8C,0x6B,0x16,0xEF,0x75,0xA3,0x6C,0x59,0xFE,0x97,0x5D,0xAC,0x34,0xD4,0x3A,
0x3B,0xA9,0x54,0xB9,0x75,0xF1,0xB7,0x8A,0x89,0x22,0x92,0x5A,0x38,0x9A,0x88,0xE6,
0xC0,0x8D,0x63,0x91,0xF2,0x72,0xDF,0x0D,0x72,0xB5,0x3F,0x89,0x60,0x75,0x15,0xD8,
0x0E,0xF5,0xAE,0x5B,0xF3,0xD3,0xFE,0xA8,0x3D,0x38,0xB2,0x7C,0x15,0xDA,0x81,0x8C,
0xE3,0xD3,0xE2,0x17,0xEC,0x37,0x51,0xA4,0x9E,0x0B,0x75,0xFA,0xD8,0xF9,0x5F,0x2B,
0x3B,0x66,0x85,0x15,0xCC,0x91,0xAF,0x95,0xDC,0xFE,0x1E,0x7B,0x63,0x54,0x5F,0x95,
0x5A,0xE0,0xB4,0x74,0x5F,0xA6,0xAF,0x53,0x1C,0xAB,0xAA,0xA6,0x92,0x75,0x31,0xDE,
0x7E,0xBA,0xE9,0xF5,0xDE,0x6C,0x7A,0xCF,0x79,0xB6,0xDC,0xB0,0x8C,0x35,0xB3,0xC1,
0x6F,0xC6,0x20,0x9E,0x99,0xD1,0xD2,0xD3,0x50,0x7A,0x8C,0x57,0xD5,0x39,0xCF,0x9A,
0x49,0x27,0x9A,0x57,0x35,0x79,0xE1,0x1A,0x8A,0x8D,0x43,0x65,0xA9,0xEC,0x80,0x54,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x28,0xBE,0xC0,0x41,0xBF,0x88,
0x1F,0x20,0xDD,0x5E,0x39,0xD3,0xEE,0xAE,0xE5,0xB5,0xC7,0x66,0x8D,0x8D,0xB9,0x05,
0xB9,0x33,0x29,0xB4,0xE1,0x5C,0xDB,0xF4,0x38,0xDF,0x7B,0xD6,0xB9,0xD4,0x6E,0x6F,
0xCE,0xD9,0x38,0x48,0xD1,0x5C,0xDF,0x28,0xC5,0x72,0xAF,0x0D,0xEE,0x53,0x1E,0xF4,
0xBD,0xD0,0xDE,0x92,0xFA,0xE7,0x64,0xCB,0xB2,0x8E,0x9D,0xDB,0xC3,0xD4,0x9B,0xA5,
0xB7,0x25,0xC5,0xEA,0x6C,0x19,0x3E,0x0D,0x3E,0x79,0x71,0x92,0xA6,0x97,0xED,0x5D,
0xA8,0xB5,0xB2,0xD2,0x55,0x39,0x6A,0x69,0x2B,0x59,0xDA,0xE6,0x32,0x78,0xD5,0xAD,
0x45,0x7B,0xFB,0x79,0xF0,0xA0,0x46,0x6E,0x8D,0xDD,0x2E,0xF4,0x23,0x37,0xDF,0x4E,
0xEC,0xA0,0xBA,0xEA,0x8E,0xAD,0x40,0xDD,0x23,0xD5,0x68,0x69,0x6D,0x4B,0x6E,0xCD,
0xAB,0x69,0xD6,0xBD,0xB1,0x3A,0x59,0x1A,0xEA,0xE5,0x6A,0xF3,0x56,0xE5,0x58,0x91,
0x15,0xD2,0x79,0x54,0x57,0x27,0xD5,0x4C,0xDF,0xD4,0x73,0x4C,0xFA,0x41,0xE3,0xBB,
0x95,0xC9,0x2F,0xBD,0x4C,0x3A,0x9E,0x6A,0x03,0xB2,0x7B,0xD4,0x8D,0xA9,0xB4,0xE9,
0xD5,0x2E,0x6D,0x5D,0x49,0x16,0x25,0x4C,0xE8,0xDA,0x91,0x36,0x9A,0xD9,0x6D,0x6A,
0xBD,0x9C,0xFC,0xCF,0x49,0x26,0x45,0x57,0xF7,0x73,0xC2,0xFB,0xA8,0x76,0x3E,0x1F,
0x1D,0xCC,0xE7,0x1A,0xC5,0xB3,0x2D,0x7D,0xD3,0xDA,0xBD,0xC0,0xDF,0x75,0x27,0x1D,
0xD2,0xEC,0xD6,0xF1,0x61,0xC3,0x73,0x8C,0x82,0x69,0x5F,0x70,0xAC,0xB3,0x25,0x23,
0x65,0xA4,0x59,0x24,0x91,0xAD,0x95,0x55,0x11,0x7B,0x93,0xBD,0x11,0xCD,0xEF,0xED,
0xE1,0x11,0xA8,0x89,0x85,0x7A,0x06,0x74,0xED,0xCD,0x37,0xE7,0xB3,0x1D,0x27,0xDE,
0xC6,0xF0,0xF7,0x89,0xAA,0x97,0x5A,0x8C,0x56,0xE4,0xFF,0x00,0xD8,0x7C,0x6B,0x1C,
0xC8,0xE6,0xA3,0xA4,0xB5,0x41,0x45,0x71,0x95,0xF2,0x3E,0xAB,0x94,0x72,0xD4,0xCD,
0x51,0x3A,0x48,0x8F,0x57,0x2F,0x88,0x52,0x36,0x22,0xF8,0x44,0x68,0x78,0x9A,0x21,
0xD2,0x6F,0x6F,0xB9,0xD7,0x5F,0x3D,0xC1,0x6D,0xAE,0xE7,0xAA,0xFA,0xC5,0x4F,0x64,
0xC7,0xB0,0x6B,0x45,0xE2,0x9A,0xE5,0x6F,0xCE,0xEB,0xE1,0xBA,0x4B,0x2D,0x47,0xD9,
0x95,0xCC,0x96,0xB1,0x1D,0xEA,0xCB,0x13,0x7D,0x45,0xED,0x63,0x95,0x51,0xBC,0x27,
0xE4,0x4E,0x2E,0xBD,0x5A,0xFF,0x00,0x7F,0xDB,0x27,0x4C,0x9B,0xBE,0x90,0xE9,0x05,
0x45,0x4C,0xF9,0xCE,0xAB,0xCF,0x47,0xA6,0x38,0xA5,0x3B,0xEA,0x15,0xF5,0x35,0x15,
0x37,0x0F,0xDC,0x3D,0x7B,0xD7,0x97,0x2B,0xD2,0x99,0xB3,0x2F,0x77,0xBF,0x72,0xB5,
0x55,0x7C,0x81,0x8F,0x3A,0x9B,0xE8,0x4E,0xE0,0xF6,0x33,0xD1,0x23,0x10,0xDB,0x8E,
0xC8,0xBF,0x6C,0x12,0x8B,0x04,0x5B,0x35,0xA7,0x2D,0xAD,0xD3,0x6E,0xE6,0xDF,0x9F,
0x61,0x8F,0x9F,0xBD,0x2A,0x29,0x15,0xA9,0xDE,0xD9,0xA4,0x93,0xE7,0x73,0x9B,0xE5,
0x1B,0x23,0xD5,0x78,0x6F,0x72,0x9F,0xB7,0x4B,0x9D,0x10,0xE9,0x2B,0xAE,0x56,0xBC,
0xAF,0x2C,0xE9,0xDD,0xBC,0x2D,0x49,0xB9,0xD0,0xE4,0x58,0xC5,0x55,0x87,0x27,0xC1,
0x6A,0x73,0xCB,0x8C,0x95,0x54,0xDF,0x6A,0x46,0x35,0x6B,0x66,0xA4,0xAA,0x72,0xD4,
0x52,0xD6,0xC7,0xDA,0xE6,0x32,0xA2,0x35,0x6B,0x51,0x5E,0xFE,0xDE,0x7C,0x28,0x11,
0xA3,0xA3,0xC7,0x4B,0x8D,0x07,0xCE,0x77,0xE9,0xBB,0x5A,0x0B,0xA6,0xA8,0x6A,0xDC,
0x0D,0xD2,0x4D,0x51,0xA5,0xA5,0xB5,0x2D,0xBF,0x37,0xAE,0xA7,0x75,0xC1,0xB1,0xAC,
0xD2,0x22,0xD7,0x39,0xAE,0xE6,0xAD,0xCA,0xB1,0x22,0x2B,0xA4,0xE5,0x55,0x15,0xC9,
0xF5,0x32,0x96,0x95,0x69,0x35,0xE3,0xAE,0xBE,0xFD,0x77,0x11,0x74,0xDC,0x8E,0xB9,
0x67,0xF6,0xAD,0x17,0xD0,0xAC,0xA7,0xF6,0x0F,0x18,0xD3,0x3C,0x22,0xFD,0x3D,0x9E,
0x9A,0xBE,0xB2,0x0E,0xFF,0x00,0xB5,0x57,0x56,0x49,0x0F,0x0F,0x91,0xEA,0xF6,0x72,
0xC4,0xE5,0x15,0x12,0x4E,0xDE,0x51,0x19,0xF3,0x05,0xC1,0xB2,0xBA,0x2D,0x5B,0xE9,
0x99,0xD6,0x72,0xAF,0xA5,0xED,0x1E,0xB9,0x65,0x99,0xB6,0x8C,0x6A,0x4E,0x05,0x26,
0x69,0x89,0x5B,0xB3,0x8B,0x93,0xEE,0x35,0xB8,0xBD,0x5C,0x13,0x3E,0x39,0x69,0xA2,
0xA8,0x7A,0x77,0x2C,0x2A,0xD8,0xA5,0x5E,0xD5,0xF1,0xC7,0xA6,0xBF,0x89,0xAE,0x57,
0xE3,0x4D,0xA4,0x6D,0x1F,0x52,0xFA,0x8F,0x6F,0xF7,0x79,0x1A,0x5B,0xAE,0xBB,0xBB,
0xD4,0x7B,0x7E,0x8F,0x60,0xFA,0xA5,0x50,0xE4,0xD3,0x9C,0x46,0xF3,0x35,0xB9,0xF7,
0x7A,0xB9,0xE3,0x56,0xB5,0x27,0xAC,0x6A,0xFA,0xAD,0xA4,0x8A,0x38,0x13,0xB6,0x9E,
0x35,0x6B,0x55,0xEE,0xEE,0x5E,0x3B,0x53,0x90,0xCB,0x1D,0x29,0x6A,0xF5,0x37,0x64,
0x5D,0x57,0x75,0xB7,0xA4,0x4D,0x66,0xB2,0xE4,0xB9,0xAE,0x9A,0x5B,0x71,0x7A,0x3C,
0xFF,0x00,0x09,0x93,0x31,0xAD,0x7D,0x6D,0x7D,0x8A,0x19,0x64,0x8A,0x29,0xE8,0xBD,
0x77,0x7C,0xCE,0x8F,0xBA,0xA3,0xC2,0x2A,0xF0,0x9E,0x8A,0x39,0x11,0x1C,0xF7,0xF3,
0xB4,0x04,0xF6,0x40,0x2A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0xA2,0xB5,0x1D,0xEE,0x3B,0x1B,0xC0,0x0E,0xC6,0xFE,0x43,
0xB1,0xBC,0x78,0x40,0x28,0x91,0xB4,0xAF,0x63,0x7F,0x20,0x28,0xB1,0xB5,0x7D,0xD1,
0x07,0xA6,0xDE,0x7C,0x22,0x20,0x04,0x8D,0xA9,0xEC,0x88,0x72,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x77,0xE1,0x50,0x30,0x7E,0xF7,0x35,0x6B,
0x78,0x7A,0x2D,0x83,0xD9,0xF3,0x7D,0x9F,0x6D,0x76,0xDD,0xAB,0xB5,0xB0,0xDC,0xD1,
0xB7,0xBC,0x46,0x5B,0xF3,0x2C,0xD5,0xCF,0xA0,0x58,0x9F,0xCC,0xB4,0x93,0x4A,0x8B,
0x13,0xA5,0x6C,0x9D,0x9F,0x23,0xFF,0x00,0x13,0x55,0x78,0xF3,0xE4,0x86,0xFB,0x44,
0xDA,0x4E,0xEA,0x75,0xEB,0xAB,0xDB,0x3A,0x9C,0x6A,0x6E,0xC9,0x28,0xB6,0xDB,0x8F,
0xD9,0x30,0xFA,0xAC,0x72,0x6B,0x14,0x97,0x7A,0x3A,0xCB,0xC6,0x6D,0x57,0x50,0xEE,
0x7E,0xD1,0x54,0xDA,0x3F,0xDD,0x24,0x71,0xA2,0xA7,0xCC,0xF5,0x57,0xAA,0xC3,0x17,
0xE2,0xFE,0x60,0x74,0xF4,0x4F,0x4A,0x3A,0x92,0xF4,0xEF,0xEA,0x67,0xAF,0x97,0x3D,
0x2D,0xD8,0xBB,0x75,0x67,0x4C,0xB7,0x0D,0x99,0x50,0xE4,0x94,0xD9,0xBD,0xB7,0x2A,
0xA4,0xB6,0x37,0x1B,0xEF,0x55,0x6D,0x57,0xDA,0xA1,0x9B,0x99,0x1C,0x91,0xA4,0xF2,
0x3B,0xB5,0x8D,0xF9,0xBD,0x26,0xF0,0xAB,0xDF,0xC3,0x7C,0x1D,0x12,0xD1,0x3E,0xA2,
0xDD,0x35,0x77,0xBD,0xB8,0xEC,0xDB,0x00,0xE9,0xBF,0x16,0xBF,0xC5,0xAD,0x59,0x63,
0xF2,0x6C,0x77,0x54,0x2D,0xF9,0x4D,0xBE,0xDB,0x3D,0x14,0x52,0xAB,0x95,0x96,0xEA,
0xE7,0x55,0x7E,0xF6,0x28,0x61,0x57,0xA7,0x98,0xD1,0x51,0x3B,0x55,0x51,0x1C,0x8A,
0xDE,0xD0,0xCA,0x3D,0x1E,0x36,0x67,0xBC,0xCD,0xB8,0xE1,0xFB,0xA6,0x66,0xED,0xB0,
0x7B,0x2D,0xBF,0x28,0xD4,0xFD,0x40,0xB9,0x64,0x74,0x52,0xE3,0x55,0x29,0x25,0xB6,
0xE2,0xDA,0xAA,0x26,0xF7,0x3E,0x99,0x5C,0xBE,0xA3,0x61,0x49,0x9E,0xE6,0x37,0xD6,
0x46,0xBF,0xE5,0xE5,0x50,0xC8,0x5D,0x00,0xB6,0xC1,0xAE,0x9B,0x39,0xE9,0x5D,0xA7,
0x1B,0x7B,0xDC,0x8E,0x07,0x26,0x35,0x98,0x59,0x65,0xB9,0xBE,0xB6,0xCB,0x35,0x4C,
0x35,0x0E,0xA7,0x49,0xAE,0x15,0x13,0x47,0xCB,0xE2,0x73,0x98,0xBC,0xB1,0xED,0x5F,
0x0E,0x5E,0x39,0xF2,0x06,0x14,0xDC,0x96,0x8E,0xF5,0x0F,0xD9,0xAF,0x58,0x7C,0xC3,
0xA8,0x4E,0xD4,0xF6,0x57,0xFD,0xDD,0xB1,0x2D,0x54,0xC1,0xA8,0xB1,0xCA,0xEB,0x3D,
0xAB,0x25,0xA5,0xB3,0x56,0x59,0xEB,0xA9,0x5D,0x1A,0x31,0xCF,0x5A,0x8F,0x0B,0x13,
0x9B,0x03,0x3C,0xB5,0x17,0xFE,0xC8,0xEF,0xC2,0xAD,0xF9,0xB9,0xEA,0x05,0x55,0xDB,
0xA8,0x1F,0x5F,0xBD,0x39,0xD2,0x6B,0xD5,0xB5,0xAC,0xC5,0xF6,0x95,0x89,0xA6,0x65,
0x7F,0xA0,0x64,0xC9,0x34,0x11,0x64,0xF7,0x36,0x31,0x29,0x69,0xDC,0xF4,0x4E,0x1C,
0xE8,0x63,0xF4,0xE5,0x6B,0xBF,0x38,0xDF,0xED,0xC8,0x13,0x23,0x7B,0x5A,0xAF,0xBC,
0x2D,0x15,0xC0,0xAC,0xF9,0xB6,0xCF,0x36,0xC3,0x6D,0xD5,0xDA,0xF8,0x2E,0x6D,0x6D,
0xEB,0x10,0x9A,0xFA,0xCB,0x35,0x6B,0xE8,0x16,0x27,0xF7,0x49,0x49,0x3C,0xA8,0xB1,
0x2C,0xCD,0x93,0xB3,0xE4,0x7F,0x87,0x35,0x57,0x8F,0x3E,0x52,0x1A,0xED,0x2F,0x69,
0x9B,0xAB,0xD7,0xFE,0xAF,0x94,0xDD,0x4D,0x75,0x2F,0x64,0x14,0x5B,0x6D,0xC7,0xF1,
0xFC,0x46,0xAF,0x1D,0xA8,0xB2,0xCD,0x78,0xA3,0xAC,0xBC,0x66,0xF5,0x75,0x0B,0xCA,
0x4F,0x54,0xCA,0x3F,0xDD,0xA4,0x71,0x23,0x93,0x87,0x3D,0x55,0xEA,0xB0,0xC7,0xF8,
0xBF,0x98,0x1D,0x4D,0x1D,0xD2,0x8E,0xA4,0xBD,0x3C,0x7A,0x9C,0xEB,0xF5,0xF7,0x4A,
0x36,0x30,0xDD,0x5A,0xD3,0x2D,0xC3,0xE5,0xB6,0xFC,0x8A,0x9B,0x35,0xB6,0xE5,0x34,
0x96,0xC4,0xC6,0x95,0x79,0x6D,0x4F,0xDA,0xA1,0x9B,0x99,0x1C,0x91,0xA4,0xF2,0x3B,
0xB5,0x89,0xF3,0x24,0x4D,0xE1,0x57,0xBD,0x51,0xBF,0x95,0xB3,0x40,0xBA,0x8E,0xF4,
0xA1,0xDF,0x66,0xB5,0x6B,0x16,0xD1,0x36,0x8F,0x16,0xBF,0x68,0xCE,0xBD,0xDE,0x53,
0x29,0xA8,0xC7,0xAC,0xD9,0x05,0x2D,0x9A,0xF3,0x8B,0x5D,0xDD,0xDE,0xB3,0x2A,0x25,
0x47,0xC9,0x2C,0x32,0x39,0xEE,0xF2,0xD4,0x5F,0x1E,0x9F,0x2A,0xD5,0x62,0xF7,0x85,
0xFB,0xB1,0x5D,0xA2,0xEF,0x2B,0x5D,0x7A,0x86,0xE4,0x3D,0x59,0x7A,0x83,0xE9,0x75,
0xB3,0x4E,0x2E,0xF0,0x63,0x09,0x86,0xE0,0x9A,0x53,0x41,0x76,0x65,0xD2,0xA2,0xC7,
0x40,0xE7,0xBA,0x59,0xEA,0x2A,0xEA,0x63,0x4F,0x4D,0xD3,0x3D,0x5C,0xE4,0x44,0x6A,
0xFB,0x48,0xFE,0x51,0x3B,0x5B,0xCC,0x52,0xD9,0x66,0xAD,0x75,0x12,0xD0,0x5E,0xA5,
0x5B,0xDF,0xD4,0xDD,0xA3,0xED,0x9E,0xD3,0xAD,0x38,0x63,0xF5,0x42,0x4A,0x2C,0x87,
0x01,0xA7,0xBC,0xC5,0x67,0xBE,0x53,0x54,0xAB,0x64,0x5A,0x7A,0xDA,0x5A,0x89,0x91,
0x61,0x92,0x34,0x6A,0xC8,0xC9,0x22,0x77,0xCD,0xF8,0x1C,0xDF,0x67,0x01,0x2C,0xBA,
0x59,0xED,0x1B,0x79,0x57,0x9D,0xEC,0x6B,0x0F,0x55,0x2D,0xFC,0x69,0xFD,0xB7,0x02,
0xCB,0xF5,0x2A,0xDD,0x49,0x8D,0x63,0xBA,0x65,0x6E,0xAF,0x8E,0xBE,0x4C,0x72,0xCD,
0x4E,0xAC,0x7A,0x25,0x45,0x44,0x6A,0xAC,0x74,0xB2,0x3A,0x28,0x95,0x51,0xAB,0xEE,
0xD9,0x1C,0xA8,0xDE,0xE4,0x63,0x76,0x0E,0x9E,0xC8,0x05,0x40,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1E,0xE0,0x71,0x58,
0x98,0xEF,0x74,0x45,0x0D,0x86,0x36,0x7E,0x16,0xA2,0x7E,0x80,0x51,0x61,0x8D,0xCB,
0xDC,0xAC,0x45,0x5F,0xCD,0x50,0x2C,0x11,0xBB,0xCB,0x9A,0x8B,0xC0,0x15,0xF4,0x99,
0xE7,0xE5,0x4F,0x21,0xB1,0x31,0xBF,0x85,0x11,0x3F,0x40,0x38,0x4D,0x03,0x24,0x6F,
0x1C,0x27,0x9F,0xCC,0xC7,0x1A,0x27,0xB4,0x7D,0x00,0xDB,0xD6,0xA0,0xEA,0x06,0xAA,
0xE9,0x2E,0x01,0x15,0xAF,0x21,0xD5,0x1B,0xAB,0x6F,0x59,0x3D,0xD9,0x6A,0x66,0x9E,
0x6B,0xA5,0x4B,0x5A,0xAD,0x63,0x95,0x64,0x73,0xBB,0x18,0xD4,0x73,0xBB,0x63,0x67,
0x0D,0x6F,0x73,0xB8,0x44,0xE4,0x0C,0x94,0xB1,0x31,0x7F,0x12,0x22,0xFE,0xA1,0xB0,
0xC6,0xCF,0x0D,0x6A,0x27,0xE8,0x05,0x16,0x08,0xDC,0xBD,0xCA,0xC6,0xAA,0xA7,0xD5,
0x50,0x2C,0x31,0xBB,0xDD,0xA8,0x05,0x25,0x8B,0xB9,0x8A,0xC6,0xF8,0xE7,0xF2,0x30,
0x5E,0xD4,0x76,0x11,0xA6,0x9B,0x49,0xD6,0x0D,0x67,0xD6,0x6C,0x27,0x2C,0xBD,0xDC,
0xAB,0xF5,0xB7,0x26,0x4C,0x9E,0xED,0x49,0x76,0x74,0x4B,0x0D,0x0C,0xE8,0xC7,0x37,
0xD3,0x83,0xB1,0x8D,0x5E,0xCF,0x9D,0xCB,0xF3,0xAB,0x97,0xDB,0xC8,0x19,0xD9,0xB1,
0x31,0xA9,0xC2,0x22,0x27,0xE8,0x72,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x01,0x47,0x2F,0x08,0x05,0x1A,0xEE,0x7D,0xF9,0xFE,0xB3,
0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xF9,0x3E,0x6E,0xD5,0xE1,0x18,0xF5,
0xFE,0x28,0x8A,0x73,0x63,0xBB,0x80,0xE4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x1B,0xFA,0xAF,0x6F,0xDB,0x1A,0xE9,
0xBD,0xB1,0x5C,0xE7,0x74,0xB7,0x77,0xC1,0x2D,0xD2,0xD7,0x49,0xF6,0x3B,0x05,0xB6,
0xA1,0x7C,0x5C,0x2E,0xB3,0xF2,0xCA,0x58,0xB8,0xFA,0xB5,0x1E,0xBE,0xA3,0xF8,0xF3,
0xE9,0xC5,0x22,0xFD,0x00,0x8B,0x9F,0x0C,0x2F,0x54,0x4B,0xF7,0x50,0x7D,0x91,0xD4,
0xE9,0xFE,0xB3,0x66,0xB3,0x5E,0x35,0x3F,0x4B,0x6A,0xFE,0xEF,0xBB,0xD7,0x57,0xCB,
0xDF,0x53,0x75,0xA2,0x99,0x5F,0x25,0x25,0x63,0x95,0x7C,0xAA,0xAA,0x24,0x90,0xB9,
0x7F,0xA5,0x02,0x2A,0xFE,0x24,0x36,0x64,0x9E,0xC0,0x54,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x7C,0xBB,0xFC,0x59,0x3A,0xE9,0xAD,0x9A,0x77,0xD5,0x96,0xA6,0xC1,0x80,
0xEB,0x0E,0x55,0x64,0xA0,0xFD,0x90,0xB4,0x49,0xF6,0x2B,0x45,0xDE,0xA6,0x9A,0x1E,
0xE7,0x24,0xFC,0xBB,0xB1,0x8F,0x46,0xF2,0xBC,0x7B,0xF0,0x7D,0x3C,0x62,0xAE,0x73,
0xB1,0xCA,0x07,0xBD,0xCA,0xE5,0x5A,0x68,0x95,0x55,0x7C,0xAA,0xFC,0x88,0x07,0xA0,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x55,0x02,0x88,0xE6,0xFB,0x73,0xE4,0xA8,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x57,0x22,0x0E,0x50,0x0A,
0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x4B,0x22,0x31,0x15,
0x57,0xE8,0x7C,0xC4,0x7C,0x5E,0x7D,0x48,0x13,0x71,0xBB,0xBF,0xB7,0x6C,0x7F,0x4E,
0x6F,0xE9,0x36,0x27,0xA3,0xCA,0xE7,0xDD,0xBE,0xCF,0x27,0x31,0xD6,0x5F,0x26,0x62,
0x7A,0xA8,0xBC,0x78,0x5F,0xB3,0x44,0xAD,0x89,0x3E,0xAD,0x7B,0xEA,0x10,0x08,0x85,
0xD0,0xB3,0xA8,0xAD,0x57,0x4D,0x5E,0xA1,0xD8,0x8E,0xB2,0x5F,0x6E,0xF2,0x41,0x85,
0x5F,0x5F,0xFB,0x3D,0x96,0xC2,0x8E,0x5E,0xC5,0xB6,0xD4,0x3D,0xA8,0xE9,0x95,0x39,
0xF2,0xB0,0x48,0xD8,0xE7,0x4F,0xAF,0xEE,0x9C,0x9F,0xCE,0x53,0xEC,0xBE,0xD9,0x5B,
0x4B,0x71,0xA3,0x8E,0xBA,0x86,0xAE,0x39,0xE0,0x99,0x88,0xF8,0xE7,0x85,0xC8,0xE6,
0x48,0xD5,0x4E,0x51,0xCD,0x54,0xF0,0xA8,0xA8,0xA8,0xA8,0xBF,0x92,0x81,0xD8,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x29,0xDF,0x17,0xD7,0xFE,0x37,0xAA,0x9F,0xF8,
0x9B,0x67,0xFF,0x00,0x92,0x73,0xEA,0x87,0x14,0xFF,0x00,0xBD,0x9B,0x7F,0xFE,0x8D,
0x17,0xFF,0x00,0x03,0x40,0xF4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xF8,0xD6,
0x55,0xC1,0x43,0x4D,0x25,0x65,0x54,0xCD,0x8E,0x28,0x9A,0xAF,0x7C,0x8F,0x72,0x35,
0xAC,0x6A,0x79,0x55,0x55,0x5F,0x08,0x88,0x9F,0x55,0x35,0x9B,0xD4,0x8F,0xE2,0x96,
0xE9,0xED,0xB2,0x46,0xD7,0xE0,0x5A,0x3B,0x78,0x5D,0x66,0xCF,0x69,0x7B,0xA3,0xFB,
0xA7,0x0E,0xAA,0x6A,0x5A,0xA8,0xE5,0x4E,0x53,0x8A,0x8B,0x97,0x0E,0x8F,0xC2,0xA7,
0x0A,0xD8,0x12,0x57,0x22,0xA7,0x0B,0xDA,0x06,0xBC,0x3A,0x76,0xFC,0x4E,0x5A,0xDF,
0xAE,0xBD,0x50,0x2C,0xFA,0xA7,0xD4,0x3F,0x71,0xB6,0xDD,0x3A,0xD1,0xCA,0x1B,0x55,
0xCD,0xB1,0x62,0x76,0x2A,0x59,0xE3,0xB4,0x41,0x3B,0xE2,0xED,0x81,0x65,0x6C,0x6D,
0x92,0x7A,0x89,0x39,0xF6,0x7C,0xAA,0xE4,0x45,0x45,0x54,0x46,0x72,0x6D,0x95,0x3E,
0x24,0x4E,0x89,0xE8,0x9C,0x7F,0xC3,0xD3,0x1E,0xFF,0x00,0x65,0xDC,0xFF,0x00,0xB2,
0x80,0xFE,0x52,0x27,0x44,0xFF,0x00,0xF1,0xF4,0xC7,0xBF,0xD9,0x77,0x3F,0xEC,0xA3,
0xF9,0x48,0x9D,0x13,0xFF,0x00,0xC7,0xD3,0x1E,0xFF,0x00,0x65,0xDC,0xFF,0x00,0xB2,
0x80,0xFE,0x52,0x27,0x44,0xFF,0x00,0xF1,0xF4,0xC7,0x7F,0xD9,0x77,0x4F,0xEC,0xA6,
0x5B,0xDA,0x07,0x55,0x8D,0x80,0x6F,0xDB,0x35,0xB9,0xE9,0xDE,0xD1,0xF7,0x23,0x6B,
0xCD,0x2F,0x36,0x6A,0x2F,0xBC,0xAB,0x28,0x28,0x29,0x2A,0xE0,0x74,0x14,0xFE,0xA3,
0x63,0xF5,0x15,0x66,0x85,0x88,0xA9,0xDE,0xF6,0xA7,0x08,0xAA,0xBE,0x53,0xC0,0x12,
0x1C,0x00,0x00,0x00,0x1C,0x24,0x91,0x18,0x8A,0xAA,0xBE,0x10,0x89,0x9A,0xE7,0xD7,
0x47,0xA5,0x36,0xDA,0x75,0x6A,0xF9,0xA1,0x5A,0xE3,0xBC,0x4B,0x26,0x3F,0x96,0x63,
0x53,0xFD,0x96,0xE7,0x66,0xA9,0xB7,0xDC,0x24,0x7D,0x24,0xBD,0xAD,0x77,0x6A,0xBA,
0x3A,0x77,0x31,0x57,0xB5,0xC8,0xBE,0x15,0x53,0xC8,0x16,0x9F,0xF2,0x91,0x3A,0x27,
0xFF,0x00,0x8F,0xA6,0x3D,0xFE,0xCB,0xB9,0xFF,0x00,0x65,0x1F,0xCA,0x44,0xE8,0x9F,
0xFE,0x3E,0x98,0xF7,0xFB,0x2E,0xE7,0xFD,0x94,0x07,0xF2,0x91,0x3A,0x27,0xFF,0x00,
0x8F,0xA6,0x3D,0xFE,0xCB,0xB9,0xFF,0x00,0x65,0x1F,0xCA,0x44,0xE8,0x9F,0xC7,0xFE,
0x1E,0x98,0xF7,0xFB,0x2E,0xE7,0xFD,0x94,0x0D,0x7D,0x75,0xDD,0xF8,0x8C,0x70,0x2A,
0x2B,0x7E,0x91,0xE7,0xBD,0x24,0xF7,0xD1,0x1D,0x6E,0x45,0x63,0xBC,0x57,0x49,0x7D,
0xA0,0xB5,0xD1,0xD4,0xFD,0x96,0xA6,0x95,0xF0,0x44,0x91,0xB2,0xAA,0x9E,0xAA,0x16,
0xC5,0x33,0x15,0xED,0x77,0x09,0xC2,0xAB,0x55,0x79,0x45,0x6A,0xF9,0x2F,0x5E,0x9B,
0xBF,0x18,0x9E,0xDF,0xB5,0x6B,0xEE,0xFD,0x39,0xEA,0x1F,0x80,0xFF,0x00,0x73,0x8B,
0xF4,0x9D,0xB1,0x2E,0x6F,0x8E,0x32,0x5A,0xBB,0x15,0x43,0xFC,0x27,0x74,0xB0,0x7C,
0xD3,0xD2,0xF2,0xAB,0xF4,0xF5,0x58,0x9E,0x55,0x55,0xA8,0x06,0xE3,0xF4,0xBF,0x56,
0x74,0xCF,0x5A,0xF0,0x9A,0x0D,0x4A,0xD2,0x0C,0xFA,0xCF,0x93,0xE3,0xD7,0x46,0x24,
0xB4,0x77,0xCB,0x05,0x64,0x75,0x74,0x95,0x2D,0xFC,0xDB,0x2B,0x15,0x5A,0xBF,0xA7,
0x3C,0xA7,0xD4,0xB8,0xD3,0xCA,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0xC2,0x56,0x77,0xA7,0xB9,0xAA,0xDF,0x89,0x47,0x63,0x3B,0x33,0xD3,0xCE,0x91,
0xDA,0xD9,0xAE,0xD8,0x36,0xD4,0xF4,0xEE,0xD1,0x9B,0x2C,0xF6,0xCA,0xB5,0xCB,0xAD,
0xB6,0x0A,0x68,0x6E,0x4B,0x34,0xF7,0x9A,0x34,0x9A,0x5F,0xB4,0xB5,0x89,0x27,0x7C,
0x89,0x23,0xD1,0xCB,0xCF,0x2E,0xEF,0x77,0x3C,0xF2,0xA0,0x44,0xAF,0x84,0x03,0x67,
0xBB,0x52,0xDC,0xB6,0xDC,0xF5,0x82,0xF3,0xB8,0x4D,0xB6,0x60,0x99,0xCD,0x65,0xB7,
0x25,0xA2,0x82,0x92,0xAB,0x2D,0xB2,0x53,0xDC,0x24,0xA6,0x8D,0xD4,0x6E,0x73,0x98,
0xC7,0x4A,0xD7,0x2B,0x5A,0xAB,0xE5,0x51,0x3C,0x2A,0x9B,0xFC,0xC6,0xB1,0xCB,0x1E,
0x21,0x60,0xA2,0xC5,0xB1,0x8B,0x4D,0x35,0xBE,0xDB,0x6D,0xA7,0x65,0x2D,0x25,0x05,
0x1C,0x69,0x1C,0x34,0xD1,0x31,0xA8,0xD6,0x46,0xC6,0xA7,0x86,0xB5,0xAD,0x44,0x44,
0x44,0xF0,0x88,0x88,0x80,0x77,0x80,0x00,0x00,0x00,0x00,0x00,0x02,0x8A,0xE4,0x4F,
0x75,0x03,0xE5,0x3B,0xE2,0xF9,0x54,0x5E,0xAF,0x55,0x3C,0x2F,0x8F,0xD8,0xDB,0x3F,
0xFC,0x93,0x9F,0x54,0x38,0x9B,0x9A,0xB8,0xCD,0xBD,0x11,0x7F,0xFA,0x34,0x5F,0x5F,
0xF3,0x1A,0x07,0xA2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x7D,0x80,0xC6,0xBB,0xAC,
0xDA,0x96,0x8A,0x6F,0x4B,0x44,0xAF,0x3B,0x79,0xDC,0x2E,0x31,0x3D,0xDF,0x15,0xBE,
0xB1,0x1B,0x55,0x43,0x4B,0x5F,0x3D,0x14,0x8E,0x54,0xE5,0x5A,0xE4,0x96,0x17,0xB5,
0xE8,0xA8,0xBE,0x78,0xE5,0x5A,0xBC,0x79,0x45,0x4F,0x06,0x81,0x7A,0x91,0x7C,0x1C,
0xDA,0xE3,0xA6,0x2B,0x5F,0xA8,0xDD,0x39,0xB5,0x17,0xF6,0xFE,0xCB,0x1F,0x74,0xA9,
0x81,0x65,0x32,0xC7,0x49,0x7A,0xA7,0x6F,0x95,0xEC,0x86,0xA7,0xE5,0x82,0xA7,0x84,
0xFA,0x3B,0xD1,0x77,0xD1,0x11,0xEA,0x04,0x12,0xE9,0x9B,0xD2,0x3F,0x3A,0xDE,0x77,
0x50,0xE6,0x74,0xFE,0xDC,0x2D,0xC7,0x25,0xD2,0x3B,0xE4,0x76,0xEA,0xEA,0xDA,0xB4,
0xBA,0x59,0x1C,0xEA,0xEA,0x47,0x53,0xC7,0xDC,0x8C,0x75,0x34,0xAE,0x89,0x78,0x77,
0xF4,0xB9,0xE3,0xEA,0x9C,0x9B,0x53,0x4F,0x81,0xFF,0x00,0x4D,0x15,0x39,0x4E,0xA2,
0x19,0x0F,0xFB,0x9F,0x07,0xF6,0xB0,0x1F,0xC8,0x7F,0xD3,0x4F,0xF2,0x88,0x64,0x3F,
0xEE,0x7C,0x1F,0xDA,0xC7,0xF2,0x1F,0xF4,0xD3,0xFC,0xA2,0x19,0x0F,0xFB,0x9F,0x07,
0xF6,0xB0,0x1F,0xC8,0x7F,0xD3,0x3F,0xF2,0x88,0xE4,0x3F,0xEE,0x7C,0x1F,0xDA,0xC9,
0x87,0xD1,0xAB,0xE1,0xF0,0xC4,0xFA,0x41,0x6B,0x6E,0x55,0xAC,0xD8,0xF6,0xE8,0x6E,
0x99,0xD4,0x99,0x3D,0x8D,0x2C,0xAF,0xB7,0xD7,0x58,0xE3,0xA0,0x6D,0x3A,0x25,0x44,
0x73,0x7A,0x88,0xF6,0xCD,0x22,0xB9,0x79,0x8B,0xB7,0x8E,0x13,0xF1,0x2A,0xF2,0x06,
0xC6,0xC0,0x00,0x00,0x01,0xF9,0xCF,0x17,0xA8,0xC5,0x6A,0x7D,0x4D,0x42,0x6F,0xE3,
0xE1,0x33,0xC1,0x37,0xD5,0xBC,0x1C,0xEF,0x76,0xB7,0x5D,0xED,0xDE,0xF1,0xCA,0x8C,
0xE2,0xE0,0x95,0xEF,0xB1,0xD3,0x63,0x30,0xD4,0xC7,0x46,0xA9,0x13,0x23,0xED,0x49,
0x56,0xA5,0xAA,0xE4,0xFD,0xDF,0x3C,0xAB,0x53,0xDC,0x0C,0x41,0xFC,0x87,0xFD,0x34,
0xFF,0x00,0x28,0x86,0x43,0xFE,0xE7,0xC1,0xFD,0xAC,0x7F,0x21,0xFF,0x00,0x4D,0x3F,
0xCA,0x21,0x90,0xFF,0x00,0xB9,0xF0,0x7F,0x6B,0x01,0xFC,0x87,0xFD,0x34,0xFF,0x00,
0x28,0x86,0x43,0xFE,0xE7,0xC1,0xFD,0xAC,0x7F,0x21,0xFF,0x00,0x4D,0x3F,0xCA,0x21,
0x91,0x7F,0xB9,0xF0,0x7F,0x6B,0x02,0x08,0x75,0xCC,0xE8,0x13,0x8E,0xF4,0x8B,0xC1,
0x34,0xEF,0x27,0xC4,0x37,0x1F,0x76,0xD4,0x1A,0xAC,0xEA,0xEB,0x55,0x6C,0x4A,0x1A,
0xAB,0x13,0x28,0x56,0x05,0x8A,0x28,0xDE,0xDE,0xCE,0xC9,0xA4,0x57,0xB9,0xCB,0x22,
0x27,0x1C,0x27,0xF5,0x9D,0xDE,0x9B,0xBF,0x0A,0xFF,0x00,0x50,0x4D,0xE9,0x3E,0xDF,
0x9F,0x6B,0x95,0xBB,0xFB,0x8B,0x60,0x95,0x3D,0xB2,0xA5,0xC7,0x2C,0xA6,0x73,0xAF,
0x15,0x91,0x2F,0x0B,0xCC,0x16,0xDE,0x5A,0xF4,0xE5,0x17,0xC3,0xA7,0x58,0x93,0xEA,
0x9D,0xC0,0x7D,0x0C,0xF4,0xC8,0xE9,0x0D,0xB4,0xBE,0x94,0xD8,0x0D,0x6E,0x23,0xB7,
0x1A,0x3B,0xF5,0x55,0xCA,0xF2,0xD6,0x7D,0xF1,0x91,0xE4,0x57,0x39,0x2A,0x2A,0x2E,
0x6F,0x6F,0xB3,0x96,0x16,0xF6,0xD3,0xC4,0x88,0xBC,0xF0,0x91,0xC6,0xD5,0xE3,0xC2,
0xAB,0xBD,0xC9,0x4E,0x9E,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x08,0x03,0xF1,0x42,0xA7,0x3D,0x0E,0x75,0xB3,0xF4,0xB2,0xFF,0x00,0xD3,0x54,0x20,
0x43,0xCF,0x82,0x3D,0x13,0xFE,0x0C,0x9A,0xDD,0xFF,0x00,0x1A,0xA8,0x3F,0xE6,0x4E,
0x37,0x82,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x23,0xA7,0x55,0x0B,0x7E,0xF1,0x5D,
0xB1,0xCC,0xEB,0x24,0xD8,0x6E,0xA4,0xD4,0x63,0x7A,0xA1,0x8F,0x51,0xAD,0xE6,0xD0,
0xEA,0x7A,0x18,0x2B,0x16,0xE4,0x94,0xFF,0x00,0xBC,0x9A,0x8B,0xD2,0x99,0x8F,0x6A,
0xAC,0xB1,0x23,0xDA,0xCE,0x13,0x94,0x91,0x23,0xF3,0xC7,0x3C,0x87,0xC7,0x26,0xF0,
0xF7,0x9F,0xB9,0x0D,0xF6,0xEB,0x1B,0xF5,0xD7,0x75,0x1A,0x84,0xB9,0x3E,0x52,0xEA,
0x28,0x6D,0xEE,0xB9,0xAD,0x14,0x14,0x8A,0xB0,0x45,0xDD,0xE9,0xB7,0xD3,0x85,0x8C,
0x67,0x8E,0xF7,0x79,0xE3,0x95,0xE7,0xC9,0xF4,0x29,0xF0,0xBD,0x6F,0x07,0xAA,0xAF,
0x50,0xDB,0x9E,0x6B,0xB8,0x0D,0xDD,0x6E,0x2E,0xAA,0xF3,0xA5,0xF8,0xAC,0x4D,0xB0,
0xDA,0x6C,0xFF,0x00,0x72,0xD0,0xD2,0x36,0xE5,0x73,0x72,0x31,0xEF,0x7F,0xAB,0x14,
0x2D,0x7A,0xB6,0x9E,0x1E,0xDE,0x53,0xBB,0x85,0x75,0x4B,0x39,0xE7,0xB5,0x50,0x0D,
0xC9,0x27,0xB0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x17,0x46,0xD7,0x27,0xCC,
0x88,0xBF,0xA8,0x1E,0x05,0xD3,0x4A,0xF4,0xE6,0xF9,0x9D,0xDA,0xB5,0x42,0xF3,0x82,
0x59,0xEA,0xF2,0x4B,0x14,0x52,0xC1,0x6E,0xBF,0x54,0x51,0xC6,0xFA,0xDA,0x08,0xE5,
0x6F,0x6C,0xB1,0xC5,0x3A,0xB7,0xBD,0x8C,0x7A,0x78,0x73,0x51,0x78,0x5F,0x1C,0xA7,
0x82,0xE1,0x4F,0x09,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0xFB,
0x01,0x6E,0xE4,0x9A,0x53,0xA7,0x19,0x96,0x57,0x63,0xCD,0xF2,0xFC,0x0E,0xCD,0x74,
0xBB,0xE3,0x32,0x49,0x35,0xA2,0xE7,0x71,0xA3,0x64,0xD5,0x16,0xB9,0x24,0x6A,0x36,
0x47,0xC0,0xF7,0x35,0x56,0x27,0x39,0xAD,0x44,0x57,0x37,0x85,0x54,0x4E,0x39,0xE0,
0xB8,0x1B,0x13,0x1B,0xE5,0x11,0x00,0xE4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x10,0x03,0xE2,0x86,0x5E,0x3A,0x1C,0xEB,0x67,0xE9,0x65,0xFF,0x00,
0xA6,0xA8,0x40,0x87,0xBF,0x04,0x7A,0xAF,0xFC,0x18,0xF5,0xB9,0x53,0xFF,0x00,0xC5,
0x54,0x1F,0xF3,0x27,0x1B,0xC1,0xFA,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x12,
0xB1,0x5C,0x9F,0x2A,0xF0,0xBF,0x98,0x1F,0x26,0x9F,0x10,0x1F,0x49,0x2C,0xDB,0x6D,
0x3D,0x58,0x20,0xD3,0xDD,0xBF,0x60,0x72,0xD4,0xD8,0x35,0xF2,0xE2,0xCB,0x96,0x1D,
0x6D,0xA3,0x67,0x0C,0x4A,0xDA,0xA9,0xDB,0x1D,0x45,0x03,0x3E,0x89,0xE9,0xD4,0xC8,
0x8E,0x44,0xF6,0x6C,0x53,0xC5,0xF9,0x1F,0x4B,0x9D,0x39,0x36,0x55,0x84,0x74,0xF9,
0xD9,0x9E,0x07,0xB4,0xEC,0x1B,0xD2,0x95,0x98,0xB5,0xBD,0xAC,0xAF,0xB8,0xC6,0xDE,
0x16,0xE5,0x5D,0x22,0xFA,0x95,0x55,0x2B,0xF5,0xFD,0xE4,0xCE,0x7A,0xA2,0x2F,0xB3,
0x7B,0x5B,0xF4,0x40,0x33,0x92,0x78,0x4E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0x76,0xF3,0xB6,0x83,0xA3,0x9B,
0xF0,0xDB,0x86,0x45,0xB5,0x7D,0x7E,0xA4,0xB8,0xCF,0x89,0xE4,0xFF,0x00,0x66,0xFB,
0x74,0x56,0x9A,0xB7,0x52,0x4E,0xEF,0x42,0xA6,0x2A,0x98,0xFB,0x65,0x6A,0x2A,0xB7,
0xF7,0x90,0xB3,0x9F,0xCD,0x39,0x4F,0xA8,0x18,0xFF,0x00,0xA7,0x5F,0x4B,0x4D,0xA9,
0xF4,0xBC,0xC4,0x32,0x2C,0x1F,0x6A,0xB6,0xAB,0xED,0x2D,0x06,0x53,0x5B,0x15,0x7D,
0x73,0x6F,0x97,0x37,0xD7,0x39,0xD2,0xC7,0x1A,0xC6,0xDE,0xD5,0x72,0x27,0x6A,0x76,
0xAA,0xF8,0x24,0x8A,0x7B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0xFB,0x01,0x64,
0xEA,0x2E,0xDE,0xB4,0x83,0x56,0x73,0xFC,0x27,0x53,0xF5,0x0F,0x05,0xA2,0xBA,0x5F,
0x34,0xEA,0xE1,0x35,0xD3,0x1E,0xB8,0x54,0xA2,0xAB,0xED,0xB5,0x13,0x53,0xBE,0x9A,
0x47,0xB7,0xE8,0xBC,0xC7,0x22,0xF8,0x5E,0x53,0x94,0x63,0xBD,0xDA,0xD5,0x4B,0xD2,
0x36,0x76,0x27,0x08,0x07,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x7F,0xFF,0xD9};
int buttonimagesize = sizeof(buttonimagejpg);
|
755627.c | /*
* Open a wild char handler
*
* djm 22/3/2000
*
*/
#include <z88.h>
char *fnexpand(far char *string, char *buffer, size_t size)
{
#asm
INCLUDE "#fileio.def"
ld ix,0
add ix,sp
ld l,(ix+6) ;filename
ld h,(ix+7)
ld e,(ix+8)
ld d,0
push de
push hl
call _cpfar2near ;get it to near spec
ld b,0 ;local
ld e,(ix+4) ;where to put it
ld d,(ix+5)
ld c,(ix+2) ;max size
call_oz(gn_fex)
ld hl,0 ;NULL - error
ret c
xor a ;terminate just in case
ld (de),a
ld l,(ix+4) ;where we expanded it to
ld h,(ix+5)
#endasm
}
|
846185.c | /*Name : Jay Jagtap
3154037
Problem Statement: To implement client-server calculator.
*/
/*
Server Side
Please pass port no as command line argument
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <ctype.h>
void error(const char *msg)
{
perror(msg);
exit(1);
}
int main(int argc, char *argv[])
{
int sockfd, newsockfd, portno;
socklen_t clilen;
char buffer[1024];
struct sockaddr_in serv_addr, cli_addr;
int n;
if (argc < 2) {
fprintf(stderr,"ERROR, no port provided\n");
exit(1);
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
error("ERROR on binding");
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd,
(struct sockaddr *) &cli_addr,
&clilen);
if (newsockfd < 0)
error("ERROR on accept");
int num1 , num2 , ans , choice;
S: n = write(newsockfd,"Enter Number 1 : ",strlen("Enter Number 1")); //Ask for Number 1
if (n < 0) error("ERROR writing to socket");
read(newsockfd, &num1, sizeof(int)); //Read No 1
printf("Client - Number 1 is : %d\n" , num1);
n = write(newsockfd,"Enter Number 2 : ",strlen("Enter Number 2")); //Ask for Number 2
if (n < 0) error("ERROR writing to socket");
read(newsockfd, &num2, sizeof(int)); //Read Number 2
printf("Client - Number 2 is : %d\n" , num2);
n = write(newsockfd,"Enter your choice : \n1.Addition\n2.Subtraction\n3.Multiplication\n4.Division\n5.Exit\n",strlen("Enter your choice : \n1.Addition\n2.Subtraction\n3.Multiplication\n4.Division\n5.Exit\n")); //Ask for choice
if (n < 0) error("ERROR writing to socket");
read(newsockfd, &choice, sizeof(int)); //Read choice
printf("Client - Choice is : %d\n" , choice);
switch(choice)
{
case 1:
ans = num1 + num2;
break;
case 2:
ans = num1 -num2;
break;
case 3:
ans = num1*num2;
break;
case 4:
ans = num1/num2;
break;
case 5 :
goto Q;
break;
}
write(newsockfd , &ans , sizeof(int));
if(choice != 5)
goto S;
Q: close(newsockfd);
close(sockfd);
return 0;
}
/*
Server side terminal:
jj@ubuntu:~/Desktop$ gcc Server.c -o Server
jj@ubuntu:~/Desktop$ ./Server 4562
Client - Number 1 is : 50
Client - Number 2 is : 110
Client - Choice is : 1
Client - Number 1 is : 50
Client - Number 2 is : 60
Client - Choice is : 2
Client - Number 1 is : 4
Client - Number 2 is : 8
Client - Choice is : 3
Client - Number 1 is : 66
Client - Number 2 is : 11
Client - Choice is : 4
Client - Number 1 is : 5
Client - Number 2 is : 7
Client - Choice is : 5
jj@ubuntu:~/Desktop$
Client side Terminal:
jj@ubuntu:~/Desktop$ gcc client.c -o client
jj@ubuntu:~/Desktop$ ./client 192.168.244.139 4562
Server - Enter Number 1
50
Server - Enter Number 2
110
Server - Enter your choice :
1.Addition
2.Subtraction
3.Multiplication
4.Division
5.Exit
1
Server - The answer is : 160
Server - Enter Number 1
50
Server - Enter Number 2
60
Server - Enter your choice :
1.Addition
2.Subtraction
3.Multiplication
4.Division
5.Exit
2
Server - The answer is : -10
Server - Enter Number 1
4
Server - Enter Number 2
8
Server - Enter your choice :
1.Addition
2.Subtraction
3.Multiplication
4.Division
5.Exit
3
Server - The answer is : 32
Server - Enter Number 1
66
Server - Enter Number 2
11
Server - Enter your choice :
1.Addition
2.Subtraction
3.Multiplication
4.Division
5.Exit
4
Server - The answer is : 6
Server - Enter Number 1
5
Server - Enter Number 2
7
Server - Enter your choice :
1.Addition
2.Subtraction
3.Multiplication
4.Division
5.Exit
5
You chose to exit, Thank You so much.jj@ubuntu:~/Desktop$
*/
|
772161.c | /* zla_gbrfsx_extended.f -- translated by f2c (version 20061008).
You must link the resulting object file with libf2c:
on Microsoft Windows system, link with libf2c.lib;
on Linux or Unix systems, link with .../path/to/libf2c.a -lm
or, if you install libf2c.a in a standard place, with -lf2c -lm
-- in that order, at the end of the command line, as in
cc *.o -lf2c -lm
Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
http://www.netlib.org/f2c/libf2c.zip
*/
#include "f2c.h"
#include "blaswrap.h"
/* Table of constant values */
static integer c__1 = 1;
static doublecomplex c_b6 = {-1.,0.};
static doublecomplex c_b8 = {1.,0.};
static doublereal c_b31 = 1.;
/* Subroutine */ int zla_gbrfsx_extended__(integer *prec_type__, integer *
trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs,
doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb,
integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b,
integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__,
integer *n_norms__, doublereal *err_bnds_norm__, doublereal *
err_bnds_comp__, doublecomplex *res, doublereal *ayb, doublecomplex *
dy, doublecomplex *y_tail__, doublereal *rcond, integer *ithresh,
doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__,
integer *info)
{
/* System generated locals */
integer ab_dim1, ab_offset, afb_dim1, afb_offset, b_dim1, b_offset,
y_dim1, y_offset, err_bnds_norm_dim1, err_bnds_norm_offset,
err_bnds_comp_dim1, err_bnds_comp_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2;
char ch__1[1];
/* Builtin functions */
double d_imag(doublecomplex *);
/* Local variables */
doublereal dxratmax, dzratmax;
integer i__, j, m;
extern /* Subroutine */ int zla_gbamv__(integer *, integer *, integer *,
integer *, integer *, doublereal *, doublecomplex *, integer *,
doublecomplex *, integer *, doublereal *, doublereal *, integer *)
;
logical incr_prec__;
doublereal prev_dz_z__, yk, final_dx_x__, final_dz_z__;
extern /* Subroutine */ int zla_wwaddw__(integer *, doublecomplex *,
doublecomplex *, doublecomplex *);
doublereal prevnormdx;
integer cnt;
doublereal dyk, eps, incr_thresh__, dx_x__, dz_z__, ymin;
extern /* Subroutine */ int zla_lin_berr__(integer *, integer *, integer *
, doublecomplex *, doublereal *, doublereal *), blas_zgbmv_x__(
integer *, integer *, integer *, integer *, integer *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *)
;
integer y_prec_state__;
extern /* Subroutine */ int blas_zgbmv2_x__(integer *, integer *, integer
*, integer *, integer *, doublecomplex *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, integer *);
doublereal dxrat, dzrat;
extern /* Subroutine */ int zgbmv_(char *, integer *, integer *, integer *
, integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *);
char trans[1];
doublereal normx, normy;
extern /* Subroutine */ int zcopy_(integer *, doublecomplex *, integer *,
doublecomplex *, integer *), zaxpy_(integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *);
extern doublereal dlamch_(char *);
doublereal normdx;
extern /* Subroutine */ int zgbtrs_(char *, integer *, integer *, integer
*, integer *, doublecomplex *, integer *, integer *,
doublecomplex *, integer *, integer *);
extern /* Character */ VOID chla_transtype__(char *, ftnlen, integer *);
doublereal hugeval;
integer x_state__, z_state__;
/* -- LAPACK routine (version 3.2.1) -- */
/* -- Contributed by James Demmel, Deaglan Halligan, Yozo Hida and -- */
/* -- Jason Riedy of Univ. of California Berkeley. -- */
/* -- April 2009 -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley and NAG Ltd. -- */
/* .. */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZLA_GBRFSX_EXTENDED improves the computed solution to a system of */
/* linear equations by performing extra-precise iterative refinement */
/* and provides error bounds and backward error estimates for the solution. */
/* This subroutine is called by ZGBRFSX to perform iterative refinement. */
/* In addition to normwise error bound, the code provides maximum */
/* componentwise error bound if possible. See comments for ERR_BNDS_NORM */
/* and ERR_BNDS_COMP for details of the error bounds. Note that this */
/* subroutine is only resonsible for setting the second fields of */
/* ERR_BNDS_NORM and ERR_BNDS_COMP. */
/* Arguments */
/* ========= */
/* PREC_TYPE (input) INTEGER */
/* Specifies the intermediate precision to be used in refinement. */
/* The value is defined by ILAPREC(P) where P is a CHARACTER and */
/* P = 'S': Single */
/* = 'D': Double */
/* = 'I': Indigenous */
/* = 'X', 'E': Extra */
/* TRANS_TYPE (input) INTEGER */
/* Specifies the transposition operation on A. */
/* The value is defined by ILATRANS(T) where T is a CHARACTER and */
/* T = 'N': No transpose */
/* = 'T': Transpose */
/* = 'C': Conjugate transpose */
/* N (input) INTEGER */
/* The number of linear equations, i.e., the order of the */
/* matrix A. N >= 0. */
/* KL (input) INTEGER */
/* The number of subdiagonals within the band of A. KL >= 0. */
/* KU (input) INTEGER */
/* The number of superdiagonals within the band of A. KU >= 0 */
/* NRHS (input) INTEGER */
/* The number of right-hand-sides, i.e., the number of columns of the */
/* matrix B. */
/* AB (input) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the N-by-N matrix A. */
/* LDAB (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,N). */
/* AFB (input) COMPLEX*16 array, dimension (LDAF,N) */
/* The factors L and U from the factorization */
/* A = P*L*U as computed by ZGBTRF. */
/* LDAFB (input) INTEGER */
/* The leading dimension of the array AF. LDAF >= max(1,N). */
/* IPIV (input) INTEGER array, dimension (N) */
/* The pivot indices from the factorization A = P*L*U */
/* as computed by ZGBTRF; row i of the matrix was interchanged */
/* with row IPIV(i). */
/* COLEQU (input) LOGICAL */
/* If .TRUE. then column equilibration was done to A before calling */
/* this routine. This is needed to compute the solution and error */
/* bounds correctly. */
/* C (input) DOUBLE PRECISION array, dimension (N) */
/* The column scale factors for A. If COLEQU = .FALSE., C */
/* is not accessed. If C is input, each element of C should be a power */
/* of the radix to ensure a reliable solution and error estimates. */
/* Scaling by powers of the radix does not cause rounding errors unless */
/* the result underflows or overflows. Rounding errors during scaling */
/* lead to refining with a matrix that is not equivalent to the */
/* input matrix, producing error estimates that may not be */
/* reliable. */
/* B (input) COMPLEX*16 array, dimension (LDB,NRHS) */
/* The right-hand-side matrix B. */
/* LDB (input) INTEGER */
/* The leading dimension of the array B. LDB >= max(1,N). */
/* Y (input/output) COMPLEX*16 array, dimension (LDY,NRHS) */
/* On entry, the solution matrix X, as computed by ZGBTRS. */
/* On exit, the improved solution matrix Y. */
/* LDY (input) INTEGER */
/* The leading dimension of the array Y. LDY >= max(1,N). */
/* BERR_OUT (output) DOUBLE PRECISION array, dimension (NRHS) */
/* On exit, BERR_OUT(j) contains the componentwise relative backward */
/* error for right-hand-side j from the formula */
/* max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) */
/* where abs(Z) is the componentwise absolute value of the matrix */
/* or vector Z. This is computed by ZLA_LIN_BERR. */
/* N_NORMS (input) INTEGER */
/* Determines which error bounds to return (see ERR_BNDS_NORM */
/* and ERR_BNDS_COMP). */
/* If N_NORMS >= 1 return normwise error bounds. */
/* If N_NORMS >= 2 return componentwise error bounds. */
/* ERR_BNDS_NORM (input/output) DOUBLE PRECISION array, dimension */
/* (NRHS, N_ERR_BNDS) */
/* For each right-hand side, this array contains information about */
/* various error bounds and condition numbers corresponding to the */
/* normwise relative error, which is defined as follows: */
/* Normwise relative error in the ith solution vector: */
/* max_j (abs(XTRUE(j,i) - X(j,i))) */
/* ------------------------------ */
/* max_j abs(X(j,i)) */
/* The array is indexed by the type of error information as described */
/* below. There currently are up to three pieces of information */
/* returned. */
/* The first index in ERR_BNDS_NORM(i,:) corresponds to the ith */
/* right-hand side. */
/* The second index in ERR_BNDS_NORM(:,err) contains the following */
/* three fields: */
/* err = 1 "Trust/don't trust" boolean. Trust the answer if the */
/* reciprocal condition number is less than the threshold */
/* sqrt(n) * slamch('Epsilon'). */
/* err = 2 "Guaranteed" error bound: The estimated forward error, */
/* almost certainly within a factor of 10 of the true error */
/* so long as the next entry is greater than the threshold */
/* sqrt(n) * slamch('Epsilon'). This error bound should only */
/* be trusted if the previous boolean is true. */
/* err = 3 Reciprocal condition number: Estimated normwise */
/* reciprocal condition number. Compared with the threshold */
/* sqrt(n) * slamch('Epsilon') to determine if the error */
/* estimate is "guaranteed". These reciprocal condition */
/* numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some */
/* appropriately scaled matrix Z. */
/* Let Z = S*A, where S scales each row by a power of the */
/* radix so all absolute row sums of Z are approximately 1. */
/* This subroutine is only responsible for setting the second field */
/* above. */
/* See Lapack Working Note 165 for further details and extra */
/* cautions. */
/* ERR_BNDS_COMP (input/output) DOUBLE PRECISION array, dimension */
/* (NRHS, N_ERR_BNDS) */
/* For each right-hand side, this array contains information about */
/* various error bounds and condition numbers corresponding to the */
/* componentwise relative error, which is defined as follows: */
/* Componentwise relative error in the ith solution vector: */
/* abs(XTRUE(j,i) - X(j,i)) */
/* max_j ---------------------- */
/* abs(X(j,i)) */
/* The array is indexed by the right-hand side i (on which the */
/* componentwise relative error depends), and the type of error */
/* information as described below. There currently are up to three */
/* pieces of information returned for each right-hand side. If */
/* componentwise accuracy is not requested (PARAMS(3) = 0.0), then */
/* ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most */
/* the first (:,N_ERR_BNDS) entries are returned. */
/* The first index in ERR_BNDS_COMP(i,:) corresponds to the ith */
/* right-hand side. */
/* The second index in ERR_BNDS_COMP(:,err) contains the following */
/* three fields: */
/* err = 1 "Trust/don't trust" boolean. Trust the answer if the */
/* reciprocal condition number is less than the threshold */
/* sqrt(n) * slamch('Epsilon'). */
/* err = 2 "Guaranteed" error bound: The estimated forward error, */
/* almost certainly within a factor of 10 of the true error */
/* so long as the next entry is greater than the threshold */
/* sqrt(n) * slamch('Epsilon'). This error bound should only */
/* be trusted if the previous boolean is true. */
/* err = 3 Reciprocal condition number: Estimated componentwise */
/* reciprocal condition number. Compared with the threshold */
/* sqrt(n) * slamch('Epsilon') to determine if the error */
/* estimate is "guaranteed". These reciprocal condition */
/* numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some */
/* appropriately scaled matrix Z. */
/* Let Z = S*(A*diag(x)), where x is the solution for the */
/* current right-hand side and S scales each row of */
/* A*diag(x) by a power of the radix so all absolute row */
/* sums of Z are approximately 1. */
/* This subroutine is only responsible for setting the second field */
/* above. */
/* See Lapack Working Note 165 for further details and extra */
/* cautions. */
/* RES (input) COMPLEX*16 array, dimension (N) */
/* Workspace to hold the intermediate residual. */
/* AYB (input) DOUBLE PRECISION array, dimension (N) */
/* Workspace. */
/* DY (input) COMPLEX*16 array, dimension (N) */
/* Workspace to hold the intermediate solution. */
/* Y_TAIL (input) COMPLEX*16 array, dimension (N) */
/* Workspace to hold the trailing bits of the intermediate solution. */
/* RCOND (input) DOUBLE PRECISION */
/* Reciprocal scaled condition number. This is an estimate of the */
/* reciprocal Skeel condition number of the matrix A after */
/* equilibration (if done). If this is less than the machine */
/* precision (in particular, if it is zero), the matrix is singular */
/* to working precision. Note that the error may still be small even */
/* if this number is very small and the matrix appears ill- */
/* conditioned. */
/* ITHRESH (input) INTEGER */
/* The maximum number of residual computations allowed for */
/* refinement. The default is 10. For 'aggressive' set to 100 to */
/* permit convergence using approximate factorizations or */
/* factorizations other than LU. If the factorization uses a */
/* technique other than Gaussian elimination, the guarantees in */
/* ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy. */
/* RTHRESH (input) DOUBLE PRECISION */
/* Determines when to stop refinement if the error estimate stops */
/* decreasing. Refinement will stop when the next solution no longer */
/* satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is */
/* the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The */
/* default value is 0.5. For 'aggressive' set to 0.9 to permit */
/* convergence on extremely ill-conditioned matrices. See LAWN 165 */
/* for more details. */
/* DZ_UB (input) DOUBLE PRECISION */
/* Determines when to start considering componentwise convergence. */
/* Componentwise convergence is only considered after each component */
/* of the solution Y is stable, which we definte as the relative */
/* change in each component being less than DZ_UB. The default value */
/* is 0.25, requiring the first bit to be stable. See LAWN 165 for */
/* more details. */
/* IGNORE_CWISE (input) LOGICAL */
/* If .TRUE. then ignore componentwise convergence. Default value */
/* is .FALSE.. */
/* INFO (output) INTEGER */
/* = 0: Successful exit. */
/* < 0: if INFO = -i, the ith argument to ZGBTRS had an illegal */
/* value */
/* ===================================================================== */
/* .. Local Scalars .. */
/* .. */
/* .. Parameters .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions.. */
/* .. */
/* .. Statement Functions .. */
/* .. */
/* .. Statement Function Definitions .. */
/* .. */
/* .. Executable Statements .. */
/* Parameter adjustments */
err_bnds_comp_dim1 = *nrhs;
err_bnds_comp_offset = 1 + err_bnds_comp_dim1;
err_bnds_comp__ -= err_bnds_comp_offset;
err_bnds_norm_dim1 = *nrhs;
err_bnds_norm_offset = 1 + err_bnds_norm_dim1;
err_bnds_norm__ -= err_bnds_norm_offset;
ab_dim1 = *ldab;
ab_offset = 1 + ab_dim1;
ab -= ab_offset;
afb_dim1 = *ldafb;
afb_offset = 1 + afb_dim1;
afb -= afb_offset;
--ipiv;
--c__;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
y_dim1 = *ldy;
y_offset = 1 + y_dim1;
y -= y_offset;
--berr_out__;
--res;
--ayb;
--dy;
--y_tail__;
/* Function Body */
if (*info != 0) {
return 0;
}
chla_transtype__(ch__1, (ftnlen)1, trans_type__);
*(unsigned char *)trans = *(unsigned char *)&ch__1[0];
eps = dlamch_("Epsilon");
hugeval = dlamch_("Overflow");
/* Force HUGEVAL to Inf */
hugeval *= hugeval;
/* Using HUGEVAL may lead to spurious underflows. */
incr_thresh__ = (doublereal) (*n) * eps;
m = *kl + *ku + 1;
i__1 = *nrhs;
for (j = 1; j <= i__1; ++j) {
y_prec_state__ = 1;
if (y_prec_state__ == 2) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__;
y_tail__[i__3].r = 0., y_tail__[i__3].i = 0.;
}
}
dxrat = 0.;
dxratmax = 0.;
dzrat = 0.;
dzratmax = 0.;
final_dx_x__ = hugeval;
final_dz_z__ = hugeval;
prevnormdx = hugeval;
prev_dz_z__ = hugeval;
dz_z__ = hugeval;
dx_x__ = hugeval;
x_state__ = 1;
z_state__ = 0;
incr_prec__ = FALSE_;
i__2 = *ithresh;
for (cnt = 1; cnt <= i__2; ++cnt) {
/* Compute residual RES = B_s - op(A_s) * Y, */
/* op(A) = A, A**T, or A**H depending on TRANS (and type). */
zcopy_(n, &b[j * b_dim1 + 1], &c__1, &res[1], &c__1);
if (y_prec_state__ == 0) {
zgbmv_(trans, &m, n, kl, ku, &c_b6, &ab[ab_offset], ldab, &y[
j * y_dim1 + 1], &c__1, &c_b8, &res[1], &c__1);
} else if (y_prec_state__ == 1) {
blas_zgbmv_x__(trans_type__, n, n, kl, ku, &c_b6, &ab[
ab_offset], ldab, &y[j * y_dim1 + 1], &c__1, &c_b8, &
res[1], &c__1, prec_type__);
} else {
blas_zgbmv2_x__(trans_type__, n, n, kl, ku, &c_b6, &ab[
ab_offset], ldab, &y[j * y_dim1 + 1], &y_tail__[1], &
c__1, &c_b8, &res[1], &c__1, prec_type__);
}
/* XXX: RES is no longer needed. */
zcopy_(n, &res[1], &c__1, &dy[1], &c__1);
zgbtrs_(trans, n, kl, ku, &c__1, &afb[afb_offset], ldafb, &ipiv[1]
, &dy[1], n, info);
/* Calculate relative changes DX_X, DZ_Z and ratios DXRAT, DZRAT. */
normx = 0.;
normy = 0.;
normdx = 0.;
dz_z__ = 0.;
ymin = hugeval;
i__3 = *n;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * y_dim1;
yk = (d__1 = y[i__4].r, abs(d__1)) + (d__2 = d_imag(&y[i__ +
j * y_dim1]), abs(d__2));
i__4 = i__;
dyk = (d__1 = dy[i__4].r, abs(d__1)) + (d__2 = d_imag(&dy[i__]
), abs(d__2));
if (yk != 0.) {
/* Computing MAX */
d__1 = dz_z__, d__2 = dyk / yk;
dz_z__ = max(d__1,d__2);
} else if (dyk != 0.) {
dz_z__ = hugeval;
}
ymin = min(ymin,yk);
normy = max(normy,yk);
if (*colequ) {
/* Computing MAX */
d__1 = normx, d__2 = yk * c__[i__];
normx = max(d__1,d__2);
/* Computing MAX */
d__1 = normdx, d__2 = dyk * c__[i__];
normdx = max(d__1,d__2);
} else {
normx = normy;
normdx = max(normdx,dyk);
}
}
if (normx != 0.) {
dx_x__ = normdx / normx;
} else if (normdx == 0.) {
dx_x__ = 0.;
} else {
dx_x__ = hugeval;
}
dxrat = normdx / prevnormdx;
dzrat = dz_z__ / prev_dz_z__;
/* Check termination criteria. */
if (! (*ignore_cwise__) && ymin * *rcond < incr_thresh__ * normy
&& y_prec_state__ < 2) {
incr_prec__ = TRUE_;
}
if (x_state__ == 3 && dxrat <= *rthresh) {
x_state__ = 1;
}
if (x_state__ == 1) {
if (dx_x__ <= eps) {
x_state__ = 2;
} else if (dxrat > *rthresh) {
if (y_prec_state__ != 2) {
incr_prec__ = TRUE_;
} else {
x_state__ = 3;
}
} else {
if (dxrat > dxratmax) {
dxratmax = dxrat;
}
}
if (x_state__ > 1) {
final_dx_x__ = dx_x__;
}
}
if (z_state__ == 0 && dz_z__ <= *dz_ub__) {
z_state__ = 1;
}
if (z_state__ == 3 && dzrat <= *rthresh) {
z_state__ = 1;
}
if (z_state__ == 1) {
if (dz_z__ <= eps) {
z_state__ = 2;
} else if (dz_z__ > *dz_ub__) {
z_state__ = 0;
dzratmax = 0.;
final_dz_z__ = hugeval;
} else if (dzrat > *rthresh) {
if (y_prec_state__ != 2) {
incr_prec__ = TRUE_;
} else {
z_state__ = 3;
}
} else {
if (dzrat > dzratmax) {
dzratmax = dzrat;
}
}
if (z_state__ > 1) {
final_dz_z__ = dz_z__;
}
}
/* Exit if both normwise and componentwise stopped working, */
/* but if componentwise is unstable, let it go at least two */
/* iterations. */
if (x_state__ != 1) {
if (*ignore_cwise__) {
goto L666;
}
if (z_state__ == 3 || z_state__ == 2) {
goto L666;
}
if (z_state__ == 0 && cnt > 1) {
goto L666;
}
}
if (incr_prec__) {
incr_prec__ = FALSE_;
++y_prec_state__;
i__3 = *n;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__;
y_tail__[i__4].r = 0., y_tail__[i__4].i = 0.;
}
}
prevnormdx = normdx;
prev_dz_z__ = dz_z__;
/* Update soluton. */
if (y_prec_state__ < 2) {
zaxpy_(n, &c_b8, &dy[1], &c__1, &y[j * y_dim1 + 1], &c__1);
} else {
zla_wwaddw__(n, &y[j * y_dim1 + 1], &y_tail__[1], &dy[1]);
}
}
/* Target of "IF (Z_STOP .AND. X_STOP)". Sun's f77 won't EXIT. */
L666:
/* Set final_* when cnt hits ithresh. */
if (x_state__ == 1) {
final_dx_x__ = dx_x__;
}
if (z_state__ == 1) {
final_dz_z__ = dz_z__;
}
/* Compute error bounds. */
if (*n_norms__ >= 1) {
err_bnds_norm__[j + (err_bnds_norm_dim1 << 1)] = final_dx_x__ / (
1 - dxratmax);
}
if (*n_norms__ >= 2) {
err_bnds_comp__[j + (err_bnds_comp_dim1 << 1)] = final_dz_z__ / (
1 - dzratmax);
}
/* Compute componentwise relative backward error from formula */
/* max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) */
/* where abs(Z) is the componentwise absolute value of the matrix */
/* or vector Z. */
/* Compute residual RES = B_s - op(A_s) * Y, */
/* op(A) = A, A**T, or A**H depending on TRANS (and type). */
zcopy_(n, &b[j * b_dim1 + 1], &c__1, &res[1], &c__1);
zgbmv_(trans, n, n, kl, ku, &c_b6, &ab[ab_offset], ldab, &y[j *
y_dim1 + 1], &c__1, &c_b8, &res[1], &c__1);
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * b_dim1;
ayb[i__] = (d__1 = b[i__3].r, abs(d__1)) + (d__2 = d_imag(&b[i__
+ j * b_dim1]), abs(d__2));
}
/* Compute abs(op(A_s))*abs(Y) + abs(B_s). */
zla_gbamv__(trans_type__, n, n, kl, ku, &c_b31, &ab[ab_offset], ldab,
&y[j * y_dim1 + 1], &c__1, &c_b31, &ayb[1], &c__1);
zla_lin_berr__(n, n, &c__1, &res[1], &ayb[1], &berr_out__[j]);
/* End of loop for each RHS. */
}
return 0;
} /* zla_gbrfsx_extended__ */
|
153159.c | // Auto-generated file. Do not edit!
// Template: src/qs8-gemm/MRx4c8-sse.c.in
// Generator: tools/xngen
//
// Copyright 2020 Google LLC
//
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree.
#include <assert.h>
#include <tmmintrin.h>
#include <xnnpack/gemm.h>
void xnn_qs8_gemm_minmax_ukernel_1x4c8__ssse3_ld64(
size_t mr,
size_t nc,
size_t kc,
const int8_t* restrict a,
size_t a_stride,
const void* restrict w,
int8_t* restrict c,
size_t cm_stride,
size_t cn_stride,
const union xnn_qs8_gemm_params params[restrict XNN_MIN_ELEMENTS(1)]) XNN_DISABLE_TSAN
{
assert(mr != 0);
assert(mr <= 1);
assert(nc != 0);
assert(kc != 0);
assert(kc % sizeof(int8_t) == 0);
assert(a != NULL);
assert(w != NULL);
assert(c != NULL);
const int8_t* a0 = a;
int8_t* c0 = c;
do {
__m128i vacc0x0 = _mm_cvtsi32_si128((int) ((const int32_t*) w)[0]);
__m128i vacc0x1 = _mm_cvtsi32_si128((int) ((const int32_t*) w)[1]);
__m128i vacc0x2 = _mm_cvtsi32_si128((int) ((const int32_t*) w)[2]);
__m128i vacc0x3 = _mm_cvtsi32_si128((int) ((const int32_t*) w)[3]);
w = (const void*) ((uintptr_t) w + 4 * sizeof(int32_t));
size_t k = 0;
while (k < kc) {
const __m128i va0 = _mm_loadl_epi64((const __m128i*) a0);
const __m128i vxa0 = _mm_unpacklo_epi8(va0, _mm_cmpgt_epi8(_mm_setzero_si128(), va0));
a0 += 8;
const __m128i vb0 = _mm_loadl_epi64((const __m128i*) w);
const __m128i vxb0 = _mm_unpacklo_epi8(vb0, _mm_cmpgt_epi8(_mm_setzero_si128(), vb0));
vacc0x0 = _mm_add_epi32(vacc0x0, _mm_madd_epi16(vxa0, vxb0));
const __m128i vb1 = _mm_loadl_epi64((const __m128i*) ((uintptr_t) w + 8 * sizeof(int8_t)));
const __m128i vxb1 = _mm_unpacklo_epi8(vb1, _mm_cmpgt_epi8(_mm_setzero_si128(), vb1));
vacc0x1 = _mm_add_epi32(vacc0x1, _mm_madd_epi16(vxa0, vxb1));
const __m128i vb2 = _mm_loadl_epi64((const __m128i*) ((uintptr_t) w + 16 * sizeof(int8_t)));
const __m128i vxb2 = _mm_unpacklo_epi8(vb2, _mm_cmpgt_epi8(_mm_setzero_si128(), vb2));
vacc0x2 = _mm_add_epi32(vacc0x2, _mm_madd_epi16(vxa0, vxb2));
const __m128i vb3 = _mm_loadl_epi64((const __m128i*) ((uintptr_t) w + 24 * sizeof(int8_t)));
const __m128i vxb3 = _mm_unpacklo_epi8(vb3, _mm_cmpgt_epi8(_mm_setzero_si128(), vb3));
vacc0x3 = _mm_add_epi32(vacc0x3, _mm_madd_epi16(vxa0, vxb3));
w = (const void*) ((uintptr_t) w + 32 * sizeof(int8_t));
k += 8 * sizeof(int8_t);
}
const __m128i vacc0x01 = _mm_hadd_epi32(vacc0x0, vacc0x1);
const __m128i vacc0x23 = _mm_hadd_epi32(vacc0x2, vacc0x3);
__m128i vacc0x0123 = _mm_hadd_epi32(vacc0x01, vacc0x23);
const __m128i vmultiplier = _mm_load_si128((const __m128i*) params->sse2.multiplier);
const __m128i vrounding = _mm_load_si128((const __m128i*) params->sse2.rounding);
const __m128i vnmask0x0123 = _mm_cmpgt_epi32(_mm_setzero_si128(), vacc0x0123);
const __m128i vabsacc0x0123 = _mm_abs_epi32(vacc0x0123);
const __m128i vabsacc0x1133 = _mm_shuffle_epi32(vabsacc0x0123, _MM_SHUFFLE(3, 3, 1, 1));
const __m128i vabsprod0x02 = _mm_mul_epu32(vabsacc0x0123, vmultiplier);
const __m128i vnmask0x02 = _mm_shuffle_epi32(vnmask0x0123, _MM_SHUFFLE(2, 2, 0, 0));
const __m128i vprod0x02 = _mm_sub_epi64(_mm_xor_si128(vabsprod0x02, vnmask0x02), vnmask0x02);
const __m128i vq31prod0x02 = _mm_srli_epi64(_mm_add_epi64(vprod0x02, vrounding), 31);
const __m128i vabsprod0x13 = _mm_mul_epu32(vabsacc0x1133, vmultiplier);
const __m128i vnmask0x13 = _mm_shuffle_epi32(vnmask0x0123, _MM_SHUFFLE(3, 3, 1, 1));
const __m128i vprod0x13 = _mm_sub_epi64(_mm_xor_si128(vabsprod0x13, vnmask0x13), vnmask0x13);
const __m128i vq31prod0x13 = _mm_srli_epi64(_mm_add_epi64(vprod0x13, vrounding), 31);
const __m128i vq31prod0x0213 = _mm_castps_si128(_mm_shuffle_ps(
_mm_castsi128_ps(vq31prod0x02), _mm_castsi128_ps(vq31prod0x13), _MM_SHUFFLE(2, 0, 2, 0)));
const __m128i vq31prod0x0123 = _mm_shuffle_epi32(vq31prod0x0213, _MM_SHUFFLE(3, 1, 2, 0));
const __m128i vremainder_mask = _mm_load_si128((const __m128i*) params->sse2.remainder_mask);
const __m128i vrem0x0123 =
_mm_add_epi32(_mm_and_si128(vq31prod0x0123, vremainder_mask), _mm_cmpgt_epi32(_mm_setzero_si128(), vq31prod0x0123));
const __m128i vremainder_threshold = _mm_load_si128((const __m128i*) params->sse2.remainder_threshold);
const __m128i vshift = _mm_load_si128((const __m128i*) params->sse2.shift);
vacc0x0123 =
_mm_sub_epi32(_mm_sra_epi32(vq31prod0x0123, vshift), _mm_cmpgt_epi32(vrem0x0123, vremainder_threshold));
const __m128i voutput_zero_point = _mm_load_si128((const __m128i*) params->sse2.output_zero_point);
__m128i vacc00x0123 = _mm_adds_epi16(_mm_packs_epi32(vacc0x0123, vacc0x0123), voutput_zero_point);
const __m128i voutput_min = _mm_load_si128((const __m128i*) params->sse2.output_min);
const __m128i voutput_max = _mm_load_si128((const __m128i*) params->sse2.output_max);
vacc00x0123 = _mm_min_epi16(_mm_max_epi16(vacc00x0123, voutput_min), voutput_max);
__m128i vout = _mm_packs_epi16(vacc00x0123, vacc00x0123);
if (nc >= 4) {
*((uint32_t*) c0) = (uint32_t) _mm_cvtsi128_si32(vout);
a0 = (const int8_t*) ((uintptr_t) a0 - k);
c0 = (int8_t*) ((uintptr_t) c0 + cn_stride);
nc -= 4;
} else {
if (nc & 2) {
*((uint16_t*) c0) = (uint16_t) _mm_extract_epi16(vout, 0);
c0 += 2;
vout = _mm_srli_epi32(vout, 16);
}
if (nc & 1) {
*((int8_t*) c0) = (int8_t) _mm_cvtsi128_si32(vout);
}
nc = 0;
}
} while (nc != 0);
}
|
989078.c | /*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2016 Damien P. George
*
* 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.
*/
#include <stdio.h>
#include "py/nlr.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "timer.h"
#include "led.h"
#include "pin.h"
#include "genhdr/pins.h"
#if defined(MICROPY_HW_LED1)
/// \moduleref pyb
/// \class LED - LED object
///
/// The LED object controls an individual LED (Light Emitting Diode).
// the default is that LEDs are not inverted, and pin driven high turns them on
#ifndef MICROPY_HW_LED_INVERTED
#define MICROPY_HW_LED_INVERTED (0)
#endif
typedef struct _pyb_led_obj_t {
mp_obj_base_t base;
mp_uint_t led_id;
const pin_obj_t *led_pin;
} pyb_led_obj_t;
STATIC const pyb_led_obj_t pyb_led_obj[] = {
{{&pyb_led_type}, 1, &MICROPY_HW_LED1},
#if defined(MICROPY_HW_LED2)
{{&pyb_led_type}, 2, &MICROPY_HW_LED2},
#if defined(MICROPY_HW_LED3)
{{&pyb_led_type}, 3, &MICROPY_HW_LED3},
#if defined(MICROPY_HW_LED4)
{{&pyb_led_type}, 4, &MICROPY_HW_LED4},
#endif
#endif
#endif
};
#define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj)
void led_init(void) {
/* Turn off LEDs and initialize */
for (int led = 0; led < NUM_LEDS; led++) {
const pin_obj_t *led_pin = pyb_led_obj[led].led_pin;
mp_hal_gpio_clock_enable(led_pin->gpio);
MICROPY_HW_LED_OFF(led_pin);
mp_hal_pin_output(led_pin);
}
}
#if defined(MICROPY_HW_LED1_PWM) \
|| defined(MICROPY_HW_LED2_PWM) \
|| defined(MICROPY_HW_LED3_PWM) \
|| defined(MICROPY_HW_LED4_PWM)
// The following is semi-generic code to control LEDs using PWM.
// It currently supports TIM1, TIM2 and TIM3, channels 1-4.
// Configure by defining the relevant MICROPY_HW_LEDx_PWM macros in mpconfigboard.h.
// If they are not defined then PWM will not be available for that LED.
#define LED_PWM_ENABLED (1)
#ifndef MICROPY_HW_LED1_PWM
#define MICROPY_HW_LED1_PWM { NULL, 0, 0, 0 }
#endif
#ifndef MICROPY_HW_LED2_PWM
#define MICROPY_HW_LED2_PWM { NULL, 0, 0, 0 }
#endif
#ifndef MICROPY_HW_LED3_PWM
#define MICROPY_HW_LED3_PWM { NULL, 0, 0, 0 }
#endif
#ifndef MICROPY_HW_LED4_PWM
#define MICROPY_HW_LED4_PWM { NULL, 0, 0, 0 }
#endif
#define LED_PWM_TIM_PERIOD (10000) // TIM runs at 1MHz and fires every 10ms
// this gives the address of the CCR register for channels 1-4
#define LED_PWM_CCR(pwm_cfg) ((volatile uint32_t*)&(pwm_cfg)->tim->CCR1 + ((pwm_cfg)->tim_channel >> 2))
typedef struct _led_pwm_config_t {
TIM_TypeDef *tim;
uint8_t tim_id;
uint8_t tim_channel;
uint8_t alt_func;
} led_pwm_config_t;
STATIC const led_pwm_config_t led_pwm_config[] = {
MICROPY_HW_LED1_PWM,
MICROPY_HW_LED2_PWM,
MICROPY_HW_LED3_PWM,
MICROPY_HW_LED4_PWM,
};
STATIC uint8_t led_pwm_state = 0;
static inline bool led_pwm_is_enabled(int led) {
return (led_pwm_state & (1 << led)) != 0;
}
// this function has a large stack so it should not be inlined
STATIC void led_pwm_init(int led) __attribute__((noinline));
STATIC void led_pwm_init(int led) {
const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];
// GPIO configuration
mp_hal_pin_config(led_pin, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_NONE, pwm_cfg->alt_func);
// TIM configuration
switch (pwm_cfg->tim_id) {
case 1: __TIM1_CLK_ENABLE(); break;
case 2: __TIM2_CLK_ENABLE(); break;
case 3: __TIM3_CLK_ENABLE(); break;
default: assert(0);
}
TIM_HandleTypeDef tim = {0};
tim.Instance = pwm_cfg->tim;
tim.Init.Period = LED_PWM_TIM_PERIOD - 1;
tim.Init.Prescaler = timer_get_source_freq(pwm_cfg->tim_id) / 1000000 - 1; // TIM runs at 1MHz
tim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim.Init.CounterMode = TIM_COUNTERMODE_UP;
tim.Init.RepetitionCounter = 0;
HAL_TIM_PWM_Init(&tim);
// PWM configuration
TIM_OC_InitTypeDef oc_init;
oc_init.OCMode = TIM_OCMODE_PWM1;
oc_init.Pulse = 0; // off
oc_init.OCPolarity = MICROPY_HW_LED_INVERTED ? TIM_OCPOLARITY_LOW : TIM_OCPOLARITY_HIGH;
oc_init.OCFastMode = TIM_OCFAST_DISABLE;
oc_init.OCNPolarity = TIM_OCNPOLARITY_HIGH; // needed for TIM1 and TIM8
oc_init.OCIdleState = TIM_OCIDLESTATE_SET; // needed for TIM1 and TIM8
oc_init.OCNIdleState = TIM_OCNIDLESTATE_SET; // needed for TIM1 and TIM8
HAL_TIM_PWM_ConfigChannel(&tim, &oc_init, pwm_cfg->tim_channel);
HAL_TIM_PWM_Start(&tim, pwm_cfg->tim_channel);
// indicate that this LED is using PWM
led_pwm_state |= 1 << led;
}
STATIC void led_pwm_deinit(int led) {
// make the LED's pin a standard GPIO output pin
const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
GPIO_TypeDef *g = led_pin->gpio;
uint32_t pin = led_pin->pin;
static const int mode = 1; // output
static const int alt = 0; // no alt func
g->MODER = (g->MODER & ~(3 << (2 * pin))) | (mode << (2 * pin));
g->AFR[pin >> 3] = (g->AFR[pin >> 3] & ~(15 << (4 * (pin & 7)))) | (alt << (4 * (pin & 7)));
led_pwm_state &= ~(1 << led);
}
#else
#define LED_PWM_ENABLED (0)
#endif
void led_state(pyb_led_t led, int state) {
if (led < 1 || led > NUM_LEDS) {
return;
}
const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
//printf("led_state(%d,%d)\n", led, state);
if (state == 0) {
// turn LED off
MICROPY_HW_LED_OFF(led_pin);
} else {
// turn LED on
MICROPY_HW_LED_ON(led_pin);
}
#if LED_PWM_ENABLED
if (led_pwm_is_enabled(led)) {
led_pwm_deinit(led);
}
#endif
}
void led_toggle(pyb_led_t led) {
if (led < 1 || led > NUM_LEDS) {
return;
}
#if LED_PWM_ENABLED
if (led_pwm_is_enabled(led)) {
// if PWM is enabled then LED has non-zero intensity, so turn it off
led_state(led, 0);
return;
}
#endif
// toggle the output data register to toggle the LED state
const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
led_pin->gpio->ODR ^= led_pin->pin_mask;
}
int led_get_intensity(pyb_led_t led) {
if (led < 1 || led > NUM_LEDS) {
return 0;
}
#if LED_PWM_ENABLED
if (led_pwm_is_enabled(led)) {
const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];
mp_uint_t i = (*LED_PWM_CCR(pwm_cfg) * 255 + LED_PWM_TIM_PERIOD - 2) / (LED_PWM_TIM_PERIOD - 1);
if (i > 255) {
i = 255;
}
return i;
}
#endif
const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
GPIO_TypeDef *gpio = led_pin->gpio;
if (gpio->ODR & led_pin->pin_mask) {
// pin is high
return MICROPY_HW_LED_INVERTED ? 0 : 255;
} else {
// pin is low
return MICROPY_HW_LED_INVERTED ? 255 : 0;
}
}
void led_set_intensity(pyb_led_t led, mp_int_t intensity) {
#if LED_PWM_ENABLED
if (intensity > 0 && intensity < 255) {
const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];
if (pwm_cfg->tim != NULL) {
// set intensity using PWM pulse width
if (!led_pwm_is_enabled(led)) {
led_pwm_init(led);
}
*LED_PWM_CCR(pwm_cfg) = intensity * (LED_PWM_TIM_PERIOD - 1) / 255;
return;
}
}
#endif
// intensity not supported for this LED; just turn it on/off
led_state(led, intensity > 0);
}
void led_debug(int n, int delay) {
led_state(1, n & 1);
led_state(2, n & 2);
led_state(3, n & 4);
led_state(4, n & 8);
HAL_Delay(delay);
}
/******************************************************************************/
/* Micro Python bindings */
void led_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
pyb_led_obj_t *self = self_in;
mp_printf(print, "LED(%lu)", self->led_id);
}
/// \classmethod \constructor(id)
/// Create an LED object associated with the given LED:
///
/// - `id` is the LED number, 1-4.
STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 1, 1, false);
// get led number
mp_int_t led_id = mp_obj_get_int(args[0]);
// check led number
if (!(1 <= led_id && led_id <= NUM_LEDS)) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED(%d) does not exist", led_id));
}
// return static led object
return (mp_obj_t)&pyb_led_obj[led_id - 1];
}
/// \method on()
/// Turn the LED on.
mp_obj_t led_obj_on(mp_obj_t self_in) {
pyb_led_obj_t *self = self_in;
led_state(self->led_id, 1);
return mp_const_none;
}
/// \method off()
/// Turn the LED off.
mp_obj_t led_obj_off(mp_obj_t self_in) {
pyb_led_obj_t *self = self_in;
led_state(self->led_id, 0);
return mp_const_none;
}
/// \method toggle()
/// Toggle the LED between on and off.
mp_obj_t led_obj_toggle(mp_obj_t self_in) {
pyb_led_obj_t *self = self_in;
led_toggle(self->led_id);
return mp_const_none;
}
/// \method intensity([value])
/// Get or set the LED intensity. Intensity ranges between 0 (off) and 255 (full on).
/// If no argument is given, return the LED intensity.
/// If an argument is given, set the LED intensity and return `None`.
mp_obj_t led_obj_intensity(mp_uint_t n_args, const mp_obj_t *args) {
pyb_led_obj_t *self = args[0];
if (n_args == 1) {
return mp_obj_new_int(led_get_intensity(self->led_id));
} else {
led_set_intensity(self->led_id, mp_obj_get_int(args[1]));
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_on_obj, led_obj_on);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_off_obj, led_obj_off);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_toggle_obj, led_obj_toggle);
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(led_obj_intensity_obj, 1, 2, led_obj_intensity);
STATIC const mp_map_elem_t led_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR_on), (mp_obj_t)&led_obj_on_obj },
{ MP_OBJ_NEW_QSTR(MP_QSTR_off), (mp_obj_t)&led_obj_off_obj },
{ MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&led_obj_toggle_obj },
{ MP_OBJ_NEW_QSTR(MP_QSTR_intensity), (mp_obj_t)&led_obj_intensity_obj },
};
STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);
const mp_obj_type_t pyb_led_type = {
{ &mp_type_type },
.name = MP_QSTR_LED,
.print = led_obj_print,
.make_new = led_obj_make_new,
.locals_dict = (mp_obj_t)&led_locals_dict,
};
#else
// For boards with no LEDs, we leave an empty function here so that we don't
// have to put conditionals everywhere.
void led_init(void) {
}
void led_state(pyb_led_t led, int state) {
}
void led_toggle(pyb_led_t led) {
}
#endif // defined(MICROPY_HW_LED1)
|
858341.c | /* Generated by Nim Compiler v1.6.2 */
#define NIM_INTBITS 64
#define NIM_EmulateOverflowChecks
#include "nimbase.h"
#include <string.h>
#include <math.h>
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
#define nimfr_(x, y)
#define nimln_(x, y)
typedef struct tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w;
typedef struct tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ;
typedef struct tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ;
typedef struct tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q;
typedef struct RootObj RootObj;
typedef struct TNimType TNimType;
typedef struct TNimNode TNimNode;
typedef struct tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw;
typedef struct tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw;
typedef struct tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ;
typedef struct tySequence__XUL1TrMU0tgXmaMFCIYgFQ tySequence__XUL1TrMU0tgXmaMFCIYgFQ;
typedef struct tyObject_TIdObj__KUwfjfUQEwGHguQbTcXu7w tyObject_TIdObj__KUwfjfUQEwGHguQbTcXu7w;
typedef struct tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g;
typedef struct tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw;
typedef struct tyObject_TType__facALICuu8zUj0hjvbTLFg tyObject_TType__facALICuu8zUj0hjvbTLFg;
typedef struct tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA;
typedef struct tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q;
typedef struct tyObject_TLoc__EtHNvCB0bgfu9bFjzx9cb6aA tyObject_TLoc__EtHNvCB0bgfu9bFjzx9cb6aA;
typedef struct tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA;
typedef struct tyObject_TLib__NBMxlJ6g3utqUlplqTTHkA tyObject_TLib__NBMxlJ6g3utqUlplqTTHkA;
typedef struct tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g;
typedef struct tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w;
typedef struct tyObject_GcHeap__1TRH1TZMaVZTnLNcIHuNFQ tyObject_GcHeap__1TRH1TZMaVZTnLNcIHuNFQ;
typedef struct tyObject_GcStack__7fytPA5bBsob6See21YMRA tyObject_GcStack__7fytPA5bBsob6See21YMRA;
typedef struct tyObject_MemRegion__x81NhDv59b8ercDZ9bi85jyg tyObject_MemRegion__x81NhDv59b8ercDZ9bi85jyg;
typedef struct tyObject_SmallChunk__tXn60W2f8h3jgAYdEmy5NQ tyObject_SmallChunk__tXn60W2f8h3jgAYdEmy5NQ;
typedef struct tyObject_BigChunk__Rv9c70Uhp2TytkX7eH78qEg tyObject_BigChunk__Rv9c70Uhp2TytkX7eH78qEg;
typedef struct tyObject_LLChunk__XsENErzHIZV9bhvyJx56wGw tyObject_LLChunk__XsENErzHIZV9bhvyJx56wGw;
typedef struct tyObject_IntSet__EZObFrE3NC9bIb3YMkY9crZA tyObject_IntSet__EZObFrE3NC9bIb3YMkY9crZA;
typedef struct tyObject_Trunk__W0r8S0Y3UGke6T9bIUWnnuw tyObject_Trunk__W0r8S0Y3UGke6T9bIUWnnuw;
typedef struct tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw;
typedef struct tyObject_HeapLinks__PDV1HBZ8CQSQJC9aOBFNRSg tyObject_HeapLinks__PDV1HBZ8CQSQJC9aOBFNRSg;
typedef struct tyTuple__ujsjpB2O9cjj3uDHsXbnSzg tyTuple__ujsjpB2O9cjj3uDHsXbnSzg;
typedef struct tyObject_GcStat__0RwLoVBHZPfUAcLczmfQAg tyObject_GcStat__0RwLoVBHZPfUAcLczmfQAg;
typedef struct tyObject_CellSet__jG87P0AI9aZtss9ccTYBIISQ tyObject_CellSet__jG87P0AI9aZtss9ccTYBIISQ;
typedef struct tyObject_PageDesc__fublkgIY4LG3mT51LU2WHg tyObject_PageDesc__fublkgIY4LG3mT51LU2WHg;
typedef struct tySequence__4mZLwkxT8rbt9bf3wXrXYNQ tySequence__4mZLwkxT8rbt9bf3wXrXYNQ;
typedef struct tySequence__rQHmYk1HzcwNxKBymIFHpA tySequence__rQHmYk1HzcwNxKBymIFHpA;
typedef struct tySequence__XMM60DtBsc6xYsIpNANkrA tySequence__XMM60DtBsc6xYsIpNANkrA;
typedef struct tyObject_Table__ZqXrnX212T9bCb4lhpQ9bFBw tyObject_Table__ZqXrnX212T9bCb4lhpQ9bFBw;
typedef struct tySequence__ChDZ6dokJ9aj9cg3KBoCU5vg tySequence__ChDZ6dokJ9aj9cg3KBoCU5vg;
typedef struct tyObject_Table__UVZI5J9aS51B4B0eYPpW1Rg tyObject_Table__UVZI5J9aS51B4B0eYPpW1Rg;
typedef struct tySequence__mWRMiYLthG9coLjkbElCxkw tySequence__mWRMiYLthG9coLjkbElCxkw;
typedef struct tyObject_Table__iowAVDkco3qpbEH0z8OmkQ tyObject_Table__iowAVDkco3qpbEH0z8OmkQ;
typedef struct tySequence__bTDCDwD2P7TodzbAefLcSw tySequence__bTDCDwD2P7TodzbAefLcSw;
typedef struct tyObject_Table__KUYGGgSxi8wBr0SXET9bi3w tyObject_Table__KUYGGgSxi8wBr0SXET9bi3w;
typedef struct tySequence__3MPVXAHA08SszBrU4ffqEg tySequence__3MPVXAHA08SszBrU4ffqEg;
typedef struct tyObject_Table__KcymdZjUsmGSK8BxmvoJgw tyObject_Table__KcymdZjUsmGSK8BxmvoJgw;
typedef struct tySequence__YCf5zJHm4JI06qpmKwPUWg tySequence__YCf5zJHm4JI06qpmKwPUWg;
typedef struct tyObject_Table__Ab4q9c36aMR4mtkEOIBzdzA tyObject_Table__Ab4q9c36aMR4mtkEOIBzdzA;
typedef struct tySequence__7lEisrXlQEzwtUKW5pzRCw tySequence__7lEisrXlQEzwtUKW5pzRCw;
typedef struct tyObject_PackedConfig__McwvRupqDAJbGrinIDFZJQ tyObject_PackedConfig__McwvRupqDAJbGrinIDFZJQ;
typedef struct tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA;
typedef struct tySequence__eHqUwlHGGaPw0TDPDeL79cQ tySequence__eHqUwlHGGaPw0TDPDeL79cQ;
typedef struct tyObject_Table__hd3qB0wXU9bWPJR7fjShhbA tyObject_Table__hd3qB0wXU9bWPJR7fjShhbA;
typedef struct tySequence__61s9cbAniKuBrdHwBhMDfQg tySequence__61s9cbAniKuBrdHwBhMDfQg;
typedef struct tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA;
typedef struct tyObject_TrunkcolonObjectType___POcWT53G7t0BSUjc31o0iA tyObject_TrunkcolonObjectType___POcWT53G7t0BSUjc31o0iA;
typedef struct tySequence__Bre9bNyuQOg1EJKitjSzn8w tySequence__Bre9bNyuQOg1EJKitjSzn8w;
typedef struct tyObject_Table__fdKWDDO1P17zvuQPReVgRA tyObject_Table__fdKWDDO1P17zvuQPReVgRA;
typedef struct tySequence__fdmz6VkIf1ewwrssKYqRFg tySequence__fdmz6VkIf1ewwrssKYqRFg;
typedef struct tyObject_Table__e2Ciu0s1q49aVQ7ULXy7l9bQ tyObject_Table__e2Ciu0s1q49aVQ7ULXy7l9bQ;
typedef struct tySequence__kxu4GK0onha2t9bo86mdVAg tySequence__kxu4GK0onha2t9bo86mdVAg;
typedef struct tySequence__48JTohSgTy339bRxHzUD8KA tySequence__48JTohSgTy339bRxHzUD8KA;
typedef struct tyObject_IdentCachecolonObjectType___TzLHS09bRH9a0TYLs39cqcNaw tyObject_IdentCachecolonObjectType___TzLHS09bRH9a0TYLs39cqcNaw;
typedef struct tySequence__s9byh6WFJ16lPMcmqdaMTHA tySequence__s9byh6WFJ16lPMcmqdaMTHA;
typedef struct tyObject_Table__Ue6w4c82v7gc7t2qntTbAw tyObject_Table__Ue6w4c82v7gc7t2qntTbAw;
typedef struct tySequence__1U9bG8RcAedEeYkQLZjVFKA tySequence__1U9bG8RcAedEeYkQLZjVFKA;
typedef struct tyObject_Table__G1v8c16HePOldLeucwe05Q tyObject_Table__G1v8c16HePOldLeucwe05Q;
typedef struct tySequence__fIB1rTQ55aFonoft9a9bmljQ tySequence__fIB1rTQ55aFonoft9a9bmljQ;
typedef struct tyObject_Table__0Y2brGGKD9bV6GJLXT9aUDgA tyObject_Table__0Y2brGGKD9bV6GJLXT9aUDgA;
typedef struct tySequence__23SMqauuRsbDANhthj9bWlA tySequence__23SMqauuRsbDANhthj9bWlA;
typedef struct tyObject_Table__NttoEzoiq5CiphZe81oadg tyObject_Table__NttoEzoiq5CiphZe81oadg;
typedef struct tySequence__squ9b9bUH4OLHf6cEMrt6hVA tySequence__squ9b9bUH4OLHf6cEMrt6hVA;
typedef struct tyObject_Table__nagDFX4QHx0s6Fvma9blmSg tyObject_Table__nagDFX4QHx0s6Fvma9blmSg;
typedef struct tySequence__pHNq3oXj9av2sEUdqaqeZjw tySequence__pHNq3oXj9av2sEUdqaqeZjw;
typedef struct tySequence__MAQKEADohlpnXTModtugbQ tySequence__MAQKEADohlpnXTModtugbQ;
typedef struct tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ;
typedef struct tyObject_Operators__EbMP71azE1HSvYAQoCH9cXA tyObject_Operators__EbMP71azE1HSvYAQoCH9cXA;
typedef struct tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag;
typedef struct TGenericSeq TGenericSeq;
typedef struct tyObject_Target__9abOl5DLX8suLujOaHSvGzw tyObject_Target__9abOl5DLX8suLujOaHSvGzw;
typedef struct NimStringDesc NimStringDesc;
typedef struct tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg;
typedef struct tyObject_MsgConfig__kV7r8HWT0SqOYW2k2ukC6A tyObject_MsgConfig__kV7r8HWT0SqOYW2k2ukC6A;
typedef struct tySequence__tNFrR3kRuS1FSwuiLGoSSA tySequence__tNFrR3kRuS1FSwuiLGoSSA;
typedef struct tySequence__Zi9cGbCWofbtABoHJ5RbLNQ tySequence__Zi9cGbCWofbtABoHJ5RbLNQ;
typedef struct tyObject_HashSet__CD8Dpv0WGmASelVaNSo6zg tyObject_HashSet__CD8Dpv0WGmASelVaNSo6zg;
typedef struct tySequence__4eRCaZmrYLLw2k30GPTiMw tySequence__4eRCaZmrYLLw2k30GPTiMw;
typedef struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ tySequence__sM4lkSb7zS6F7OVMvW9cffQ;
typedef struct tyTuple__47w2DboNEPf69aPgubZdd7Q tyTuple__47w2DboNEPf69aPgubZdd7Q;
typedef struct tySequence__pK3qSsBZwdXd6qyUMkd5Jw tySequence__pK3qSsBZwdXd6qyUMkd5Jw;
typedef struct tyObject_SuggestcolonObjectType___bkMuTTb2G70XfpzAiyNrnQ tyObject_SuggestcolonObjectType___bkMuTTb2G70XfpzAiyNrnQ;
typedef struct tyObject_ProfileDatacolonObjectType___rPBBfFL4X0b9cQ6rfMNPXig tyObject_ProfileDatacolonObjectType___rPBBfFL4X0b9cQ6rfMNPXig;
typedef struct tyTuple__kN8up2W6YKc5YA9avn5mV5w tyTuple__kN8up2W6YKc5YA9avn5mV5w;
typedef struct tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q;
typedef struct tySequence__8fytVdU59b5aj319cog2ztLw tySequence__8fytVdU59b5aj319cog2ztLw;
typedef struct tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg;
typedef struct tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w;
typedef struct tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A;
typedef struct tyObject_Int128__9a9axPfb75jdWY25AamJewkA tyObject_Int128__9a9axPfb75jdWY25AamJewkA;
typedef struct tyTuple__nsNHL3sm0TZE9bootw2pEXw tyTuple__nsNHL3sm0TZE9bootw2pEXw;
typedef struct tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA;
typedef struct tyTuple__Fb1Z8PVtzpSjrvQ67oA88w tyTuple__Fb1Z8PVtzpSjrvQ67oA88w;
typedef struct tyTuple__QVkyTCL0msoEdWvhK6TYrw tyTuple__QVkyTCL0msoEdWvhK6TYrw;
typedef struct tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww;
typedef struct tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg;
typedef struct tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q;
typedef struct tyObject_OrderedTable__ZZvSdVkA2s2sIyifu4cpkg tyObject_OrderedTable__ZZvSdVkA2s2sIyifu4cpkg;
typedef struct tySequence__MlAD6nAPq9bHKla9cWiIZP0g tySequence__MlAD6nAPq9bHKla9cWiIZP0g;
typedef struct tySequence__oLpBKXzW3hF9aCVMo5EymfQ tySequence__oLpBKXzW3hF9aCVMo5EymfQ;
typedef struct tyTuple__tA7Q8IrfOKH7Mn89cK9cBAIg tyTuple__tA7Q8IrfOKH7Mn89cK9cBAIg;
typedef struct tyObject_Iface__uvkV248cZcsEQKaQm7C9aEA tyObject_Iface__uvkV248cZcsEQKaQm7C9aEA;
typedef struct tySequence__vv5mGmK03BCr5e3LTZA5Hw tySequence__vv5mGmK03BCr5e3LTZA5Hw;
typedef struct tyObject_LoadedModule__14iJKkvOiWT62KF2D8f9c5w tyObject_LoadedModule__14iJKkvOiWT62KF2D8f9c5w;
typedef struct tyObject_PackedModule__ZSxNoR2V6oK5xosmtvhjNQ tyObject_PackedModule__ZSxNoR2V6oK5xosmtvhjNQ;
typedef struct tySequence__PXIzfWocnrafGz5p3CP5LA tySequence__PXIzfWocnrafGz5p3CP5LA;
typedef struct tySequence__9bAGqSvkAaFL9bWjsEPslrFA tySequence__9bAGqSvkAaFL9bWjsEPslrFA;
typedef struct tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw;
typedef struct tySequence__29bS0n2QNyO1R7e0qMMOvLA tySequence__29bS0n2QNyO1R7e0qMMOvLA;
typedef struct tySequence__b89aLriiJnVTD186H6zNIgg tySequence__b89aLriiJnVTD186H6zNIgg;
typedef struct tySequence__REuPuHuSlOkZ0Q5oqzDrQg tySequence__REuPuHuSlOkZ0Q5oqzDrQg;
typedef struct tySequence__I9aQmO9asXXWJ58UI9c8BCSzA tySequence__I9aQmO9asXXWJ58UI9c8BCSzA;
typedef struct tySequence__NyaOkf8ZwxP6rkRF5TOkew tySequence__NyaOkf8ZwxP6rkRF5TOkew;
typedef struct tySequence__L9bOt8CaTEmIjgtuZvp6syg tySequence__L9bOt8CaTEmIjgtuZvp6syg;
typedef struct tySequence__im8UB2GsZvUaQ4a1wKGWhQ tySequence__im8UB2GsZvUaQ4a1wKGWhQ;
typedef struct tySequence__xxnXDLpoqBo8zJzP9b1073g tySequence__xxnXDLpoqBo8zJzP9b1073g;
typedef struct tySequence__DfmUmNgVGnYaiV1I6227tw tySequence__DfmUmNgVGnYaiV1I6227tw;
typedef struct tySequence__t8Uv4lEJ4lkuECvP9c6JMhA tySequence__t8Uv4lEJ4lkuECvP9c6JMhA;
typedef struct tyObject_BiTable__SMd2CpsYscvX1veKoGcqmg tyObject_BiTable__SMd2CpsYscvX1veKoGcqmg;
typedef struct tyObject_BiTable__DyMEQOe8VsqcG49bIhU69bBQ tyObject_BiTable__DyMEQOe8VsqcG49bIhU69bBQ;
typedef struct tySequence__IHUFRsFxZNv7YydiUO2esQ tySequence__IHUFRsFxZNv7YydiUO2esQ;
typedef struct tyObject_Table__CE4eiu6FavV1vmUiTXQ70g tyObject_Table__CE4eiu6FavV1vmUiTXQ70g;
typedef struct tySequence__9bT7o0CflHuiE4VhmtqBPCw tySequence__9bT7o0CflHuiE4VhmtqBPCw;
typedef struct tyObject_PackedEncoder__B9cE9a0GbvqWW9aHf4N7RAaIw tyObject_PackedEncoder__B9cE9a0GbvqWW9aHf4N7RAaIw;
typedef struct tyObject_Table__TRm6MPqklA8EYBmBMY117Q tyObject_Table__TRm6MPqklA8EYBmBMY117Q;
typedef struct tySequence__9cnx3zXnWzeclW8Ko4oUgAQ tySequence__9cnx3zXnWzeclW8Ko4oUgAQ;
typedef struct tyTuple__l7R9cf53SDCcRmz9aWTyEKqQ tyTuple__l7R9cf53SDCcRmz9aWTyEKqQ;
typedef struct tySequence__O5RcspOP32YJ4YtU5ppxxA tySequence__O5RcspOP32YJ4YtU5ppxxA;
typedef struct tyObject_LazyType__Q19c34D32PKyTKlx6R6yODg tyObject_LazyType__Q19c34D32PKyTKlx6R6yODg;
typedef struct tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ;
typedef struct tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ;
typedef struct tyTuple__o67sDX0wYbEuhI9cJYAbDtg tyTuple__o67sDX0wYbEuhI9cJYAbDtg;
typedef struct tySequence__Or1y9bNpmj8PM8AcK9c9cg7RA tySequence__Or1y9bNpmj8PM8AcK9c9cg7RA;
typedef struct tyObject_LazyInstantiation__rlce0Sj8mBfLfm69c2yVTZg tyObject_LazyInstantiation__rlce0Sj8mBfLfm69c2yVTZg;
typedef struct tySequence__ipEvhpHAmm8ZCn9bZAOdNYA tySequence__ipEvhpHAmm8ZCn9bZAOdNYA;
typedef struct tyObject_TInstantiation__5LqgVn6Tq9ainQRK7TQAQxA tyObject_TInstantiation__5LqgVn6Tq9ainQRK7TQAQxA;
typedef struct tyTuple__9aNnDWBFMF44sfFinBpMT4Q tyTuple__9aNnDWBFMF44sfFinBpMT4Q;
typedef struct tyTuple__dT8l9anHpNRgQSBAI9ctQ2wg tyTuple__dT8l9anHpNRgQSBAI9ctQ2wg;
typedef struct tySequence__159bHWBGAOOs6U7OZ9cQlO0g tySequence__159bHWBGAOOs6U7OZ9cQlO0g;
typedef struct tyTuple__VrD6plbUKJjYKM0lCr3hGQ tyTuple__VrD6plbUKJjYKM0lCr3hGQ;
typedef struct tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA;
typedef struct tyTuple__1ZbjBgxAbnye0IFMZ6w4OA tyTuple__1ZbjBgxAbnye0IFMZ6w4OA;
typedef struct tyTuple__xYhUhS7X82rKTqbT9bRfCnw tyTuple__xYhUhS7X82rKTqbT9bRfCnw;
typedef struct tyTuple__rplX06U9bjhu9asm5pWdgqsA tyTuple__rplX06U9bjhu9asm5pWdgqsA;
typedef struct tyTuple__1mtQ8sCEE7DbfIuQciv9b5Q tyTuple__1mtQ8sCEE7DbfIuQciv9b5Q;
typedef struct tyTuple__xDU9bZmv1ZbZkJDaATBekIQ tyTuple__xDU9bZmv1ZbZkJDaATBekIQ;
typedef struct tyTuple__a9bBCAQ2tegdUQVlHYxdJ2A tyTuple__a9bBCAQ2tegdUQVlHYxdJ2A;
typedef struct tyTuple__3i6hlQmqrn6m7tuVN8FHjQ tyTuple__3i6hlQmqrn6m7tuVN8FHjQ;
typedef struct tyTuple__OJFzEczluV8Jmo9bRpBfkzw tyTuple__OJFzEczluV8Jmo9bRpBfkzw;
typedef struct tyTuple__2SGm9aGCXuo7XSQ9bqD29axXw tyTuple__2SGm9aGCXuo7XSQ9bqD29axXw;
typedef struct tyTuple__F3gkSrMB1qp2Tvf9bixVXwg tyTuple__F3gkSrMB1qp2Tvf9bixVXwg;
typedef struct tyTuple__wcNatyuf8WOqAhGLhSvgiw tyTuple__wcNatyuf8WOqAhGLhSvgiw;
typedef struct tyObject_BTree__VZdzO0Tlflp7WMN4gS8oPg tyObject_BTree__VZdzO0Tlflp7WMN4gS8oPg;
typedef struct tyObject_NodecolonObjectType___dNELmBSmY7nthjhZupWO6g tyObject_NodecolonObjectType___dNELmBSmY7nthjhZupWO6g;
typedef struct tyTuple__4o9cW9aUwdGqgZI9bSHHYnbaQ tyTuple__4o9cW9aUwdGqgZI9bSHHYnbaQ;
typedef struct tyTuple__z822nu9bFF1AlQnLrHjdwpA tyTuple__z822nu9bFF1AlQnLrHjdwpA;
typedef struct tyObject_TFileInfo__GE3hAakXKOEpch4ap3zXAw tyObject_TFileInfo__GE3hAakXKOEpch4ap3zXAw;
typedef struct tyTuple__QeWl6B6ffS4pU6WWrtcrDw tyTuple__QeWl6B6ffS4pU6WWrtcrDw;
typedef struct tyObject_Cfile__i9cKq1ZGd1wgagjUEHLVFtg tyObject_Cfile__i9cKq1ZGd1wgagjUEHLVFtg;
typedef struct tyTuple__awOivLjlO76sGdHY7nQUjQ tyTuple__awOivLjlO76sGdHY7nQUjQ;
typedef struct tyTuple__0q9cmhneJEKnQERTpXXdz6Q tyTuple__0q9cmhneJEKnQERTpXXdz6Q;
typedef struct tyObject_PackedNode__7lDGAZiNp4zbO65GEpoKow tyObject_PackedNode__7lDGAZiNp4zbO65GEpoKow;
typedef struct tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg;
typedef struct tyTuple__Izx9aRSX9a0diDXD84jOS9aMQ tyTuple__Izx9aRSX9a0diDXD84jOS9aMQ;
typedef struct tyTuple__Q7r9caOmeWqQGZCIBHhGRUA tyTuple__Q7r9caOmeWqQGZCIBHhGRUA;
typedef struct tyTuple__7Wlwbz8zSe7Udyf7mmsd9cg tyTuple__7Wlwbz8zSe7Udyf7mmsd9cg;
typedef struct tyTuple__XyJ8LOAZzVVXSsmt09b8uWw tyTuple__XyJ8LOAZzVVXSsmt09b8uWw;
typedef struct tyObject_PackedInstantiation__39cWRURu69agjI9c1ohiUmxiA tyObject_PackedInstantiation__39cWRURu69agjI9c1ohiUmxiA;
typedef struct tySequence__vC9cvg0R8tfBaOXXi3sfMzw tySequence__vC9cvg0R8tfBaOXXi3sfMzw;
typedef struct tyTuple__9aoobCDZB4x41HJSOmh0mwA tyTuple__9aoobCDZB4x41HJSOmh0mwA;
typedef struct tyTuple__g0Q6Qx15nK53ce9aLo7YyrA tyTuple__g0Q6Qx15nK53ce9aLo7YyrA;
typedef struct tyObject_PackedSym__XjVn21MwvH8ij6CfopYZWw tyObject_PackedSym__XjVn21MwvH8ij6CfopYZWw;
typedef struct tyObject_PackedLib__oa01YzfeXO9bbIDH9cIki4Hw tyObject_PackedLib__oa01YzfeXO9bbIDH9cIki4Hw;
typedef struct tyObject_PackedType__IhXsK7mrwumUBtEqbZ2BqA tyObject_PackedType__IhXsK7mrwumUBtEqbZ2BqA;
typedef struct tyTuple__8x6vq4Dc9aLvKX9actMeR9avQ tyTuple__8x6vq4Dc9aLvKX9actMeR9avQ;
typedef struct tyTuple__UvldbCB6B9ayi9bGYW7vJNLA tyTuple__UvldbCB6B9ayi9bGYW7vJNLA;
typedef NU8 tyEnum_TNimKind__jIBKr1ejBgsfM33Kxw4j7A;
typedef NU8 tySet_tyEnum_TNimTypeFlag__v8QUszD1sWlSIWZz7mC4bQ;
typedef N_NIMCALL_PTR(void, tyProc__ojoeKfW4VYIm36I9cpDTQIg) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, tyProc__WSm2xU5ARYv9aAR4l0z9c9auQ) (void* p);
struct TNimType {
NI size;
NI align;
tyEnum_TNimKind__jIBKr1ejBgsfM33Kxw4j7A kind;
tySet_tyEnum_TNimTypeFlag__v8QUszD1sWlSIWZz7mC4bQ flags;
TNimType* base;
TNimNode* node;
void* finalizer;
tyProc__ojoeKfW4VYIm36I9cpDTQIg marker;
tyProc__WSm2xU5ARYv9aAR4l0z9c9auQ deepcopy;
};
struct RootObj {
TNimType* m_type;
};
struct tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w {
RootObj Sup;
tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen;
};
struct tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ {
tySequence__XUL1TrMU0tgXmaMFCIYgFQ* data;
NI counter;
NIM_BOOL isSorted;
};
struct tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw {
tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w Sup;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module;
tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph;
tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config;
tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ sigConflicts;
};
typedef NU8 tyEnum_TNimNodeKind__unfNsxrcATrufDZmpBq4HQ;
struct TNimNode {
tyEnum_TNimNodeKind__unfNsxrcATrufDZmpBq4HQ kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g {
NI32 module;
NI32 item;
};
struct tyObject_TIdObj__KUwfjfUQEwGHguQbTcXu7w {
RootObj Sup;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g itemId;
};
typedef NU8 tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw;
typedef NU16 tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg;
struct tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q {
NU16 line;
NI16 col;
NI32 fileIndex;
};
typedef NU64 tySet_tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw;
typedef NU32 tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg;
typedef NU8 tyEnum_TLocKind__O7PRFZKuiBBWbku09cayVBg;
typedef NU8 tyEnum_TStorageLoc__JK9cKMX3XnqHaUky9b6gkGEw;
typedef NU16 tySet_tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA;
struct tyObject_TLoc__EtHNvCB0bgfu9bFjzx9cb6aA {
tyEnum_TLocKind__O7PRFZKuiBBWbku09cayVBg k;
tyEnum_TStorageLoc__JK9cKMX3XnqHaUky9b6gkGEw storage;
tySet_tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA flags;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* lode;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* r;
};
struct tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ {
tyObject_TIdObj__KUwfjfUQEwGHguQbTcXu7w Sup;
tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw kind;
union{
struct {tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* gcUnsafetyReason;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* transformedBody;
} _kind_1;
struct {tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* guard;
NI bitsize;
NI alignment;
} _kind_2;
};
tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg magic;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA* name;
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* owner;
tySet_tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw flags;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* ast;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options;
NI position;
NI offset;
tyObject_TLoc__EtHNvCB0bgfu9bFjzx9cb6aA loc;
tyObject_TLib__NBMxlJ6g3utqUlplqTTHkA* annex;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* constraint;
};
struct tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g {
NI refcount;
TNimType* typ;
};
struct tyObject_GcStack__7fytPA5bBsob6See21YMRA {
void* bottom;
};
struct tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w {
NI len;
NI cap;
tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g** d;
};
typedef tyObject_SmallChunk__tXn60W2f8h3jgAYdEmy5NQ* tyArray__SPr7N6UKfuF549bNPiUvSRw[256];
typedef NU32 tyArray__BHbOSqU1t9b3Gt7K2c6fQig[24];
typedef tyObject_BigChunk__Rv9c70Uhp2TytkX7eH78qEg* tyArray__N1u1nqOgmuJN9cSZrnMHgOQ[32];
typedef tyArray__N1u1nqOgmuJN9cSZrnMHgOQ tyArray__B6durA4ZCi1xjJvRtyYxMg[24];
typedef tyObject_Trunk__W0r8S0Y3UGke6T9bIUWnnuw* tyArray__lh2A89ahMmYg9bCmpVaplLbA[256];
struct tyObject_IntSet__EZObFrE3NC9bIb3YMkY9crZA {
tyArray__lh2A89ahMmYg9bCmpVaplLbA data;
};
typedef tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw* tyArray__0aOLqZchNi8nWtMTi8ND8w[2];
struct tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw {
tyArray__0aOLqZchNi8nWtMTi8ND8w link;
NI key;
NI upperBound;
NI level;
};
struct tyTuple__ujsjpB2O9cjj3uDHsXbnSzg {
tyObject_BigChunk__Rv9c70Uhp2TytkX7eH78qEg* Field0;
NI Field1;
};
typedef tyTuple__ujsjpB2O9cjj3uDHsXbnSzg tyArray__LzOv2eCDGiceMKQstCLmhw[30];
struct tyObject_HeapLinks__PDV1HBZ8CQSQJC9aOBFNRSg {
NI len;
tyArray__LzOv2eCDGiceMKQstCLmhw chunks;
tyObject_HeapLinks__PDV1HBZ8CQSQJC9aOBFNRSg* next;
};
struct tyObject_MemRegion__x81NhDv59b8ercDZ9bi85jyg {
NI minLargeObj;
NI maxLargeObj;
tyArray__SPr7N6UKfuF549bNPiUvSRw freeSmallChunks;
NU32 flBitmap;
tyArray__BHbOSqU1t9b3Gt7K2c6fQig slBitmap;
tyArray__B6durA4ZCi1xjJvRtyYxMg matrix;
tyObject_LLChunk__XsENErzHIZV9bhvyJx56wGw* llmem;
NI currMem;
NI maxMem;
NI freeMem;
NI occ;
NI lastSize;
tyObject_IntSet__EZObFrE3NC9bIb3YMkY9crZA chunkStarts;
tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw* root;
tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw* deleted;
tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw* last;
tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw* freeAvlNodes;
NIM_BOOL locked;
NIM_BOOL blockChunkSizeIncrease;
NI nextChunkSize;
tyObject_AvlNode__IaqjtwKhxLEpvDS9bct9blEw bottomData;
tyObject_HeapLinks__PDV1HBZ8CQSQJC9aOBFNRSg heapLinks;
};
struct tyObject_GcStat__0RwLoVBHZPfUAcLczmfQAg {
NI stackScans;
NI cycleCollections;
NI maxThreshold;
NI maxStackSize;
NI maxStackCells;
NI cycleTableSize;
NI64 maxPause;
};
struct tyObject_CellSet__jG87P0AI9aZtss9ccTYBIISQ {
NI counter;
NI max;
tyObject_PageDesc__fublkgIY4LG3mT51LU2WHg* head;
tyObject_PageDesc__fublkgIY4LG3mT51LU2WHg** data;
};
struct tyObject_GcHeap__1TRH1TZMaVZTnLNcIHuNFQ {
tyObject_GcStack__7fytPA5bBsob6See21YMRA stack;
NI cycleThreshold;
NI zctThreshold;
tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w zct;
tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w decStack;
tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w tempStack;
NI recGcLock;
tyObject_MemRegion__x81NhDv59b8ercDZ9bi85jyg region;
tyObject_GcStat__0RwLoVBHZPfUAcLczmfQAg stat;
tyObject_CellSet__jG87P0AI9aZtss9ccTYBIISQ marked;
tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w additionalRoots;
NI gcThreadId;
};
struct tyObject_Table__ZqXrnX212T9bCb4lhpQ9bFBw {
tySequence__ChDZ6dokJ9aj9cg3KBoCU5vg* data;
NI counter;
};
struct tyObject_Table__UVZI5J9aS51B4B0eYPpW1Rg {
tySequence__mWRMiYLthG9coLjkbElCxkw* data;
NI counter;
};
struct tyObject_Table__iowAVDkco3qpbEH0z8OmkQ {
tySequence__bTDCDwD2P7TodzbAefLcSw* data;
NI counter;
};
typedef tyObject_Table__iowAVDkco3qpbEH0z8OmkQ tyArray__pxY9cgs6r9cBvGwlO8XZ9ccbQ[5];
struct tyObject_Table__KUYGGgSxi8wBr0SXET9bi3w {
tySequence__3MPVXAHA08SszBrU4ffqEg* data;
NI counter;
};
struct tyObject_Table__KcymdZjUsmGSK8BxmvoJgw {
tySequence__YCf5zJHm4JI06qpmKwPUWg* data;
NI counter;
};
struct tyObject_Table__Ab4q9c36aMR4mtkEOIBzdzA {
tySequence__7lEisrXlQEzwtUKW5pzRCw* data;
NI counter;
};
typedef NU8 tyEnum_TBackend__4OBsgZ9cscH2JLUE5Wcz01g;
typedef NU8 tyEnum_TGCMode__tkz389aDYNd8ykeZszCuBSw;
typedef NU8 tyEnum_TSystemCC__1eWBJUonHMOnlBwsOvpFmA;
typedef NU64 tySet_tyEnum_TGlobalOption__RAfAEZqjnKMDumgyKKc1qw;
struct tyObject_PackedConfig__McwvRupqDAJbGrinIDFZJQ {
tyEnum_TBackend__4OBsgZ9cscH2JLUE5Wcz01g backend;
tyEnum_TGCMode__tkz389aDYNd8ykeZszCuBSw selectedGC;
tyEnum_TSystemCC__1eWBJUonHMOnlBwsOvpFmA cCompiler;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options;
tySet_tyEnum_TGlobalOption__RAfAEZqjnKMDumgyKKc1qw globalOptions;
};
struct tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA {
NI counter;
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* data;
};
struct tyObject_Table__hd3qB0wXU9bWPJR7fjShhbA {
tySequence__61s9cbAniKuBrdHwBhMDfQg* data;
NI counter;
};
typedef NI tyArray__emiAJ8okywrJw7ZHLzlXbQ[34];
struct tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA {
NI elems;
NI counter;
NI max;
tyObject_TrunkcolonObjectType___POcWT53G7t0BSUjc31o0iA* head;
tySequence__Bre9bNyuQOg1EJKitjSzn8w* data;
tyArray__emiAJ8okywrJw7ZHLzlXbQ a;
};
struct tyObject_Table__fdKWDDO1P17zvuQPReVgRA {
tySequence__fdmz6VkIf1ewwrssKYqRFg* data;
NI counter;
};
struct tyObject_Table__e2Ciu0s1q49aVQ7ULXy7l9bQ {
tySequence__kxu4GK0onha2t9bo86mdVAg* data;
NI counter;
};
typedef struct {
N_NIMCALL_PTR(NIM_BOOL, ClP_0) (void* ClE_0);
void* ClE_0;
} tyProc__In3g79a0qTcRmbTbJp9ba9ctg;
typedef tyObject_TType__facALICuu8zUj0hjvbTLFg* tyArray__9bjuenwQUcqO3lbmS2wX7uA[65];
struct tyObject_Table__Ue6w4c82v7gc7t2qntTbAw {
tySequence__1U9bG8RcAedEeYkQLZjVFKA* data;
NI counter;
};
struct tyObject_Table__G1v8c16HePOldLeucwe05Q {
tySequence__fIB1rTQ55aFonoft9a9bmljQ* data;
NI counter;
};
typedef N_NIMCALL_PTR(tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*, tyProc__VHDwJFdIqpwtpUGuxiXUwg) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* m, NI32 fileIdx);
typedef N_NIMCALL_PTR(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, tyProc__mjUN9alLJ31lnSKkUsuyWMw) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* m, NI32 fileIdx);
struct tyObject_Table__0Y2brGGKD9bV6GJLXT9aUDgA {
tySequence__23SMqauuRsbDANhthj9bWlA* data;
NI counter;
};
struct tyObject_Table__NttoEzoiq5CiphZe81oadg {
tySequence__squ9b9bUH4OLHf6cEMrt6hVA* data;
NI counter;
};
struct tyObject_Table__nagDFX4QHx0s6Fvma9blmSg {
tySequence__pHNq3oXj9av2sEUdqaqeZjw* data;
NI counter;
};
typedef N_NIMCALL_PTR(void, tyProc__TjycsqkDBjsxd4da6KYTng) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info);
typedef N_NIMCALL_PTR(void, tyProc__Mrj9cEgtPER9bAXMDB9cTXrfQ) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* owner, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* body);
typedef N_NIMCALL_PTR(NIM_BOOL, tyProc__J7Jq15ZScfKLqcLx8sEz9cA) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TType__facALICuu8zUj0hjvbTLFg* formal, tyObject_TType__facALICuu8zUj0hjvbTLFg* actual);
struct tyObject_Operators__EbMP71azE1HSvYAQoCH9cXA {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opNot;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opContains;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opLe;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opLt;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opAnd;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opOr;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opIsNil;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opEq;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opAdd;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opSub;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opMul;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opDiv;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* opLen;
};
struct tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ {
tySequence__4mZLwkxT8rbt9bf3wXrXYNQ* ifaces;
tySequence__rQHmYk1HzcwNxKBymIFHpA* packed_0;
tySequence__XMM60DtBsc6xYsIpNANkrA* encoders;
tyObject_Table__ZqXrnX212T9bCb4lhpQ9bFBw typeInstCache;
tyObject_Table__UVZI5J9aS51B4B0eYPpW1Rg procInstCache;
tyArray__pxY9cgs6r9cBvGwlO8XZ9ccbQ attachedOps;
tyObject_Table__KUYGGgSxi8wBr0SXET9bi3w methodsPerType;
tyObject_Table__KcymdZjUsmGSK8BxmvoJgw enumToStringProcs;
tyObject_Table__Ab4q9c36aMR4mtkEOIBzdzA emittedTypeInfo;
tyObject_PackedConfig__McwvRupqDAJbGrinIDFZJQ startupPackedConfig;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA packageSyms;
tyObject_Table__hd3qB0wXU9bWPJR7fjShhbA modulesPerPackage;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA deps;
tyObject_Table__fdKWDDO1P17zvuQPReVgRA importDeps;
NIM_BOOL suggestMode;
NIM_BOOL invalidTransitiveClosure;
tyObject_Table__e2Ciu0s1q49aVQ7ULXy7l9bQ inclToMod;
tySequence__48JTohSgTy339bRxHzUD8KA* importStack;
RootObj* backend;
tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config;
tyObject_IdentCachecolonObjectType___TzLHS09bRH9a0TYLs39cqcNaw* cache;
RootObj* vm;
tyProc__In3g79a0qTcRmbTbJp9ba9ctg doStopCompile;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* usageSym;
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* owners;
tySequence__s9byh6WFJ16lPMcmqdaMTHA* methods;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* systemModule;
tyArray__9bjuenwQUcqO3lbmS2wX7uA sysTypes;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA compilerprocs;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA exposed;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA packageTypes;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* emptyNode;
tyObject_Table__Ue6w4c82v7gc7t2qntTbAw canonTypes;
tyObject_Table__G1v8c16HePOldLeucwe05Q symBodyHashes;
tyProc__VHDwJFdIqpwtpUGuxiXUwg importModuleCallback;
tyProc__mjUN9alLJ31lnSKkUsuyWMw includeFileCallback;
tyObject_Table__0Y2brGGKD9bV6GJLXT9aUDgA cacheSeqs;
tyObject_Table__NttoEzoiq5CiphZe81oadg cacheCounters;
tyObject_Table__nagDFX4QHx0s6Fvma9blmSg cacheTables;
tySequence__MAQKEADohlpnXTModtugbQ* passes;
tyProc__TjycsqkDBjsxd4da6KYTng onDefinition;
tyProc__TjycsqkDBjsxd4da6KYTng onDefinitionResolveForward;
tyProc__TjycsqkDBjsxd4da6KYTng onUsage;
tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ* globalDestructors;
tyProc__Mrj9cEgtPER9bAXMDB9cTXrfQ strongSemCheck;
tyProc__J7Jq15ZScfKLqcLx8sEz9cA compatibleProps;
tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen;
tyObject_Operators__EbMP71azE1HSvYAQoCH9cXA operators;
};
struct tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag {
RootObj Sup;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* typeInfo;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* constants;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* code;
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* forwarded;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA generatedSyms;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA typeInfoGenerated;
NI unique;
NIM_BOOL inSystem;
};
struct TGenericSeq {
NI len;
NI reserved;
};
typedef NU8 tyEnum_TSystemCPU__XYDt7D1G3qcClFyZy1Ky9ag;
typedef NU8 tyEnum_TSystemOS__s7Mlr1t66SUqP6BKJMXLaQ;
struct NimStringDesc {
TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct tyObject_Target__9abOl5DLX8suLujOaHSvGzw {
tyEnum_TSystemCPU__XYDt7D1G3qcClFyZy1Ky9ag targetCPU;
tyEnum_TSystemCPU__XYDt7D1G3qcClFyZy1Ky9ag hostCPU;
tyEnum_TSystemOS__s7Mlr1t66SUqP6BKJMXLaQ targetOS;
tyEnum_TSystemOS__s7Mlr1t66SUqP6BKJMXLaQ hostOS;
NI intSize;
NI floatSize;
NI ptrSize;
NimStringDesc* tnl;
};
typedef NU8 tySet_tyEnum_TErrorOutput__fBf8Teueoz9aAkO5cXaxrpA;
struct tyObject_MsgConfig__kV7r8HWT0SqOYW2k2ukC6A {
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q trackPos;
NIM_BOOL trackPosAttached;
tySet_tyEnum_TErrorOutput__fBf8Teueoz9aAkO5cXaxrpA errorOutputs;
tySequence__tNFrR3kRuS1FSwuiLGoSSA* msgContext;
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q lastError;
tyObject_Table__Ab4q9c36aMR4mtkEOIBzdzA filenameToIndexTbl;
tySequence__Zi9cGbCWofbtABoHJ5RbLNQ* fileInfos;
NI32 systemFileIdx;
};
typedef NU8 tyEnum_FilenameOption__eL86bAtPxXWHj24F5gOMFQ;
typedef NU8 tyEnum_Command__0zjcIQ623TIRGPdtjLwTFA;
typedef NU8 tyEnum_ExceptionSystem__1mkAogyaDAT7g9cQjzsgKLQ;
typedef NU8 tyEnum_SymbolFilesOption__gBES9bqm1ru9ape8SeMRAFgQ;
struct tyObject_HashSet__CD8Dpv0WGmASelVaNSo6zg {
tySequence__4eRCaZmrYLLw2k30GPTiMw* data;
NI counter;
};
typedef NU32 tySet_tyEnum_Feature__01UoAKYz1MxZiuG1X2VhNQ;
typedef NU8 tySet_tyEnum_LegacyFeature__hGCD9aOrxPvpXn4Ne6W6OVA;
typedef NU8 tyEnum_IdeCmd__1Ced39bl5eePmZ1PKMPXigQ;
typedef NU8 tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug[11];
struct tyTuple__47w2DboNEPf69aPgubZdd7Q {
NI Field0;
NI Field1;
NI Field2;
};
typedef NU8 tySet_tyEnum_StdOrrKind__6cbmyTzDPaZU9afMe4mz3Ug;
typedef struct {
N_NIMCALL_PTR(void, ClP_0) (tyObject_SuggestcolonObjectType___bkMuTTb2G70XfpzAiyNrnQ* result, void* ClE_0);
void* ClE_0;
} tyProc__YD0MR9bJ2x4beJkZdnjXN9cA;
typedef struct {
N_NIMCALL_PTR(void, ClP_0) (NimStringDesc* output, void* ClE_0);
void* ClE_0;
} tyProc__k2HFjxisIgDALbEUFojxaQ;
typedef NU8 tyEnum_Severity__x5BWBPGAbIH9clm5pmNp5DA;
typedef struct {
N_NIMCALL_PTR(void, ClP_0) (tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info, NimStringDesc* msg, tyEnum_Severity__x5BWBPGAbIH9clm5pmNp5DA severity, void* ClE_0);
void* ClE_0;
} tyProc__oL9coyIA2VDTGdUcur9aL9bew;
struct tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw {
tyEnum_TBackend__4OBsgZ9cscH2JLUE5Wcz01g backend;
tyObject_Target__9abOl5DLX8suLujOaHSvGzw target;
NI linesCompiled;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options;
tySet_tyEnum_TGlobalOption__RAfAEZqjnKMDumgyKKc1qw globalOptions;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* macrosToExpand;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* arcToExpand;
tyObject_MsgConfig__kV7r8HWT0SqOYW2k2ukC6A m;
tyEnum_FilenameOption__eL86bAtPxXWHj24F5gOMFQ filenameOption;
NimStringDesc* unitSep;
NI evalTemplateCounter;
NI evalMacroCounter;
NI8 exitcode;
tyEnum_Command__0zjcIQ623TIRGPdtjLwTFA cmd;
NimStringDesc* cmdInput;
NIM_BOOL projectIsCmd;
NIM_BOOL implicitCmd;
tyEnum_TGCMode__tkz389aDYNd8ykeZszCuBSw selectedGC;
tyEnum_ExceptionSystem__1mkAogyaDAT7g9cQjzsgKLQ exc;
NIM_BOOL hintProcessingDots;
NI verbosity;
NI numberOfProcessors;
NF lastCmdTime;
tyEnum_SymbolFilesOption__gBES9bqm1ru9ape8SeMRAFgQ symbolFiles;
NI spellSuggestMax;
tyObject_HashSet__CD8Dpv0WGmASelVaNSo6zg cppDefines;
NimStringDesc* headerFile;
tySet_tyEnum_Feature__01UoAKYz1MxZiuG1X2VhNQ features;
tySet_tyEnum_LegacyFeature__hGCD9aOrxPvpXn4Ne6W6OVA legacyFeatures;
NimStringDesc* arguments;
tyEnum_IdeCmd__1Ced39bl5eePmZ1PKMPXigQ ideCmd;
NIM_BOOL oldNewlines;
tyEnum_TSystemCC__1eWBJUonHMOnlBwsOvpFmA cCompiler;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug modifiedyNotes;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug cmdlineNotes;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug foreignPackageNotes;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug notes;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug warningAsErrors;
tySet_tyEnum_TMsgKind__7VIi6mabc7hDxpCmSMYIug mainPackageNotes;
NI mainPackageId;
NI errorCounter;
NI hintCounter;
NI warnCounter;
NI errorMax;
NI maxLoopIterationsVM;
NIM_BOOL isVmTrace;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* configVars;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* symbols;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* packageCache;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* nimblePaths;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* searchPaths;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* lazyPaths;
NimStringDesc* outFile;
NimStringDesc* outDir;
NimStringDesc* jsonBuildFile;
NimStringDesc* prefixDir;
NimStringDesc* libpath;
NimStringDesc* nimcacheDir;
tyTuple__47w2DboNEPf69aPgubZdd7Q nimStdlibVersion;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* dllOverrides;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* moduleOverrides;
tyObject_StringTableObj__V5PVrt9bIxZEeV7lfvqqtNg* cfileSpecificOptions;
NimStringDesc* projectName;
NimStringDesc* projectPath;
NimStringDesc* projectFull;
NIM_BOOL projectIsStdin;
tySet_tyEnum_StdOrrKind__6cbmyTzDPaZU9afMe4mz3Ug lastMsgWasDot;
NI32 projectMainIdx;
NI32 projectMainIdx2;
NimStringDesc* command;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* commandArgs;
NimStringDesc* commandLine;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* extraCmds;
NIM_BOOL keepComments;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* implicitImports;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* implicitIncludes;
NimStringDesc* docSeeSrcUrl;
NimStringDesc* docRoot;
NimStringDesc* docCmd;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* configFiles;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* cIncludes;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* cLibs;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* cLinkedLibs;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* externalToLink;
NimStringDesc* linkOptionsCmd;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* compileOptionsCmd;
NimStringDesc* linkOptions;
NimStringDesc* compileOptions;
NimStringDesc* cCompilerPath;
tySequence__pK3qSsBZwdXd6qyUMkd5Jw* toCompile;
tyProc__YD0MR9bJ2x4beJkZdnjXN9cA suggestionResultHook;
NI suggestVersion;
NI suggestMaxResults;
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q lastLineInfo;
tyProc__k2HFjxisIgDALbEUFojxaQ writelnHook;
tyProc__oL9coyIA2VDTGdUcur9aL9bew structuredErrorHook;
NimStringDesc* cppCustomNamespace;
NimStringDesc* nimMainPrefix;
tyObject_ProfileDatacolonObjectType___rPBBfFL4X0b9cQ6rfMNPXig* vmProfileData;
};
typedef NU8 tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw;
struct tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q {
NI32 module;
NI32 symId;
NI32 typeId_0;
NIM_BOOL sealed;
};
typedef NU32 tySet_tyEnum_TNodeFlag__jyh9acXHkhZANSSvPIY7ZLg;
typedef NU8 tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw;
struct tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw {
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info;
tySet_tyEnum_TNodeFlag__jyh9acXHkhZANSSvPIY7ZLg flags;
tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw kind;
union{
struct {NI64 intVal;
} _kind_1;
struct {NF floatVal;
} _kind_2;
struct {NimStringDesc* strVal;
} _kind_3;
struct {tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* sym;
} _kind_4;
struct {tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA* ident;
} _kind_5;
struct {tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ* sons;
} _kind_6;
};
};
struct tyTuple__kN8up2W6YKc5YA9avn5mV5w {
NimStringDesc* Field0;
NI Field1;
NI Field2;
};
struct tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* procDef;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* globals;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* locals;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* body;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options;
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module;
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* g;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA generatedParamCopies;
NIM_BOOL beforeRetNeeded;
NI unique;
tySequence__8fytVdU59b5aj319cog2ztLw* blocks;
NI extraIndent;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* up;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA declaredGlobals;
};
struct tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg {
NI id;
NIM_BOOL isLoop;
};
typedef NU8 tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg;
struct tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA {
RootObj Sup;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* left;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* right;
NI L;
NimStringDesc* data;
};
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__mrugoXXRZUEeG9bEXo9auBKw[2];
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__qTjAvTvKF9anytN1At69aJMQ[1];
struct tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA {
NI id;
NimStringDesc* s;
tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA* next;
NI h;
};
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__JiWwrsTRC6xqNlGcBthSVA[1];
typedef NU8 tyEnum_TNodeFlag__jyh9acXHkhZANSSvPIY7ZLg;
typedef NU8 tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg;
typedef NU8 tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA;
struct tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w {
tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg kind;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA typ;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* res;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* address;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpLoc;
};
typedef NU8 tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag;
typedef NU8 tyEnum_TCallingConvention__yjAJ8w0h1PBaSwSGJ3P7IA;
typedef NU64 tySet_tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw;
struct tyObject_TType__facALICuu8zUj0hjvbTLFg {
tyObject_TIdObj__KUwfjfUQEwGHguQbTcXu7w Sup;
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag kind;
tyEnum_TCallingConvention__yjAJ8w0h1PBaSwSGJ3P7IA callConv;
tySet_tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw flags;
tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A* sons;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* owner;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* sym;
NI64 size;
NI16 align;
NI16 paddingAtEnd;
NI16 lockLevel;
tyObject_TLoc__EtHNvCB0bgfu9bFjzx9cb6aA loc;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typeInst;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g uniqueId;
};
typedef NU8 tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag[9];
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__wqYjTJU9ab2ZgEFMaQc3vNA[3];
typedef NU32 tyArray__FleBT9cC2nxhgiXmSYYnEKA[4];
struct tyObject_Int128__9a9axPfb75jdWY25AamJewkA {
tyArray__FleBT9cC2nxhgiXmSYYnEKA udata;
};
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__wm6rkCVggH4IozhLUEP19bg[8];
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__YcHYlgE5mhtkt9a3rnoucVg[7];
typedef NU8 tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w;
typedef NU8 tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw;
typedef NU8 tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw;
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__duFhZXIIlrbrM62cWjNekg[5];
typedef NU8 tySet_tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw[21];
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__f7nG5LD47BH5K9c6mASit3g[4];
typedef NU8 tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA;
typedef NU8 tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA;
typedef NimStringDesc* tyArray__Re75IspeoxXy2oCZHwcRrA[2];
typedef tyArray__Re75IspeoxXy2oCZHwcRrA tyArray__k29ck4gbaHsaWs9bvWKy0w5w[62];
struct tyTuple__nsNHL3sm0TZE9bootw2pEXw {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* Field0;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* Field1;
};
typedef NU8 tySet_tyChar__nmiMWKVIe46vacnhAFrQvw[32];
struct tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA {
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag a;
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag b;
};
struct tyTuple__Fb1Z8PVtzpSjrvQ67oA88w {
NimStringDesc* Field0;
tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw Field1;
};
typedef tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tyArray__dNfZYyzVYdaWfURv4pxodA[6];
typedef NU8 tyEnum_LegacyFeature__hGCD9aOrxPvpXn4Ne6W6OVA;
struct tyTuple__QVkyTCL0msoEdWvhK6TYrw {
NimStringDesc* Field0;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA Field1;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA Field2;
};
typedef NU16 tyEnum_TSpecialWord__ycbpMCRV6Cd2eBh3X9biEiw;
typedef NimStringDesc* tyArray__nHXaesL0DJZHyVS07ARPRA[1];
typedef NU8 tyEnum_TGlobalOption__RAfAEZqjnKMDumgyKKc1qw;
struct tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* Field0;
tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* Field1;
};
struct tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww {
NI version;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* sources;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* names;
NimStringDesc* mappings;
NimStringDesc* file;
};
typedef NU8 tyEnum_JsonNodeKind__RUngo7nCHe6O8aBGIcrhtg;
struct tyObject_OrderedTable__ZZvSdVkA2s2sIyifu4cpkg {
tySequence__MlAD6nAPq9bHKla9cWiIZP0g* data;
NI counter;
NI first;
NI last;
};
struct tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q {
NIM_BOOL isUnquoted;
tyEnum_JsonNodeKind__RUngo7nCHe6O8aBGIcrhtg kind;
union{
struct {NimStringDesc* str;
} _kind_1;
struct {NI64 num;
} _kind_2;
struct {NF fnum;
} _kind_3;
struct {NIM_BOOL bval;
} _kind_4;
struct {tyObject_OrderedTable__ZZvSdVkA2s2sIyifu4cpkg fields;
} _kind_6;
struct {tySequence__oLpBKXzW3hF9aCVMo5EymfQ* elems;
} _kind_7;
};
};
typedef NU8 tyArray__qtqsWM5aXmcpMIVmvq3kAA[16];
struct tyTuple__tA7Q8IrfOKH7Mn89cK9cBAIg {
tyArray__qtqsWM5aXmcpMIVmvq3kAA Field0;
NI Field1;
};
struct tyObject_Iface__uvkV248cZcsEQKaQm7C9aEA {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module;
tySequence__vv5mGmK03BCr5e3LTZA5Hw* converters;
tySequence__vv5mGmK03BCr5e3LTZA5Hw* patterns;
tySequence__vv5mGmK03BCr5e3LTZA5Hw* pureEnums;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA interf;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA interfHidden;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* uniqueName;
};
typedef NU8 tyEnum_ModuleStatus__MgSLMPwZ4GVYYz7Kn9bmm6Q;
struct tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw {
tySequence__29bS0n2QNyO1R7e0qMMOvLA* nodes;
};
typedef NU8 tySet_tyEnum_ModuleBackendFlag__fgnyOEZ7Q9aYVj8O59afcT4g;
struct tyObject_BiTable__SMd2CpsYscvX1veKoGcqmg {
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* vals;
tySequence__9bAGqSvkAaFL9bWjsEPslrFA* keys;
};
struct tyObject_BiTable__DyMEQOe8VsqcG49bIhU69bBQ {
tySequence__IHUFRsFxZNv7YydiUO2esQ* vals;
tySequence__9bAGqSvkAaFL9bWjsEPslrFA* keys;
};
struct tyObject_PackedModule__ZSxNoR2V6oK5xosmtvhjNQ {
NimStringDesc* definedSymbols;
tySet_tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw moduleFlags;
tySequence__PXIzfWocnrafGz5p3CP5LA* includes;
tySequence__9bAGqSvkAaFL9bWjsEPslrFA* imports;
tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw toReplay;
tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw topLevel;
tyObject_PackedTree__8otSrA7MENGYESDkEP7nnw bodies;
tySequence__b89aLriiJnVTD186H6zNIgg* exports;
tySequence__b89aLriiJnVTD186H6zNIgg* hidden;
tySequence__REuPuHuSlOkZ0Q5oqzDrQg* reexports;
tySequence__b89aLriiJnVTD186H6zNIgg* compilerProcs;
tySequence__48JTohSgTy339bRxHzUD8KA* converters;
tySequence__48JTohSgTy339bRxHzUD8KA* methods;
tySequence__48JTohSgTy339bRxHzUD8KA* trmacros;
tySequence__48JTohSgTy339bRxHzUD8KA* pureEnums;
tySequence__I9aQmO9asXXWJ58UI9c8BCSzA* macroUsages;
tySequence__NyaOkf8ZwxP6rkRF5TOkew* typeInstCache;
tySequence__L9bOt8CaTEmIjgtuZvp6syg* procInstCache;
tySequence__im8UB2GsZvUaQ4a1wKGWhQ* attachedOps;
tySequence__xxnXDLpoqBo8zJzP9b1073g* methodsPerType;
tySequence__NyaOkf8ZwxP6rkRF5TOkew* enumToStringProcs;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* emittedTypeInfo;
tySet_tyEnum_ModuleBackendFlag__fgnyOEZ7Q9aYVj8O59afcT4g backendFlags;
tySequence__DfmUmNgVGnYaiV1I6227tw* syms;
tySequence__t8Uv4lEJ4lkuECvP9c6JMhA* types;
tyObject_BiTable__SMd2CpsYscvX1veKoGcqmg strings;
tyObject_BiTable__DyMEQOe8VsqcG49bIhU69bBQ numbers;
tyObject_PackedConfig__McwvRupqDAJbGrinIDFZJQ cfg;
};
struct tyObject_Table__CE4eiu6FavV1vmUiTXQ70g {
tySequence__9bT7o0CflHuiE4VhmtqBPCw* data;
NI counter;
};
struct tyObject_LoadedModule__14iJKkvOiWT62KF2D8f9c5w {
tyEnum_ModuleStatus__MgSLMPwZ4GVYYz7Kn9bmm6Q status;
NIM_BOOL symsInit;
NIM_BOOL typesInit;
NIM_BOOL loadedButAliveSetChanged;
tyObject_PackedModule__ZSxNoR2V6oK5xosmtvhjNQ fromDisk;
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* syms;
tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A* types;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module;
tyObject_Table__CE4eiu6FavV1vmUiTXQ70g iface;
tyObject_Table__CE4eiu6FavV1vmUiTXQ70g ifaceHidden;
};
struct tyObject_Table__TRm6MPqklA8EYBmBMY117Q {
tySequence__9cnx3zXnWzeclW8Ko4oUgAQ* data;
NI counter;
};
struct tyObject_PackedEncoder__B9cE9a0GbvqWW9aHf4N7RAaIw {
NI32 thisModule;
NI32 lastFile;
NU32 lastLit;
tyObject_Table__TRm6MPqklA8EYBmBMY117Q filenames;
tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A* pendingTypes;
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* pendingSyms;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA typeMarker;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA symMarker;
tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config;
};
struct tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ {
NU32 module;
NI32 item;
};
struct tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ {
NI module;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ packed_0;
};
struct tyObject_LazyType__Q19c34D32PKyTKlx6R6yODg {
tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ id;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
};
struct tyTuple__l7R9cf53SDCcRmz9aWTyEKqQ {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tySequence__O5RcspOP32YJ4YtU5ppxxA* Field2;
};
struct tyObject_LazyInstantiation__rlce0Sj8mBfLfm69c2yVTZg {
NI module;
tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ sym;
tySequence__ipEvhpHAmm8ZCn9bZAOdNYA* concreteTypes;
tyObject_TInstantiation__5LqgVn6Tq9ainQRK7TQAQxA* inst;
};
struct tyTuple__o67sDX0wYbEuhI9cJYAbDtg {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tySequence__Or1y9bNpmj8PM8AcK9c9cg7RA* Field2;
};
struct tyTuple__9aNnDWBFMF44sfFinBpMT4Q {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* Field2;
};
struct tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA {
tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ id;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* sym;
};
struct tyTuple__VrD6plbUKJjYKM0lCr3hGQ {
NI Field0;
tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA Field1;
};
struct tyTuple__dT8l9anHpNRgQSBAI9ctQ2wg {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tySequence__159bHWBGAOOs6U7OZ9cQlO0g* Field2;
};
struct tyTuple__1ZbjBgxAbnye0IFMZ6w4OA {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA Field2;
};
struct tyTuple__xYhUhS7X82rKTqbT9bRfCnw {
NI Field0;
NimStringDesc* Field1;
NI32 Field2;
};
struct tyTuple__rplX06U9bjhu9asm5pWdgqsA {
NI Field0;
tyObject_ItemId__ozxAxZLHTQ9c3akTzYvt67g Field1;
tyObject_TStrTable__f07aOS3dr28kGa5wcE29aFA Field2;
};
struct tyTuple__1mtQ8sCEE7DbfIuQciv9b5Q {
NI Field0;
NI32 Field1;
tySequence__48JTohSgTy339bRxHzUD8KA* Field2;
};
struct tyTuple__xDU9bZmv1ZbZkJDaATBekIQ {
NI Field0;
NI32 Field1;
NI32 Field2;
};
struct tyTuple__a9bBCAQ2tegdUQVlHYxdJ2A {
tySequence__eHqUwlHGGaPw0TDPDeL79cQ* Field0;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* Field1;
};
struct tyTuple__3i6hlQmqrn6m7tuVN8FHjQ {
NI Field0;
tyArray__qtqsWM5aXmcpMIVmvq3kAA Field1;
tyObject_TType__facALICuu8zUj0hjvbTLFg* Field2;
};
struct tyTuple__OJFzEczluV8Jmo9bRpBfkzw {
NI Field0;
NI Field1;
tyArray__qtqsWM5aXmcpMIVmvq3kAA Field2;
};
struct tyTuple__2SGm9aGCXuo7XSQ9bqD29axXw {
NI Field0;
NimStringDesc* Field1;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* Field2;
};
struct tyTuple__F3gkSrMB1qp2Tvf9bixVXwg {
NI Field0;
NimStringDesc* Field1;
NI64 Field2;
};
struct tyObject_BTree__VZdzO0Tlflp7WMN4gS8oPg {
tyObject_NodecolonObjectType___dNELmBSmY7nthjhZupWO6g* root;
NI entries;
};
struct tyTuple__wcNatyuf8WOqAhGLhSvgiw {
NI Field0;
NimStringDesc* Field1;
tyObject_BTree__VZdzO0Tlflp7WMN4gS8oPg Field2;
};
typedef N_NIMCALL_PTR(tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w*, tyProc__jkSFMhvPZ1AdGcvT2dK9a2w) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen);
typedef N_NIMCALL_PTR(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, tyProc__A7Sdoem70tRxSEmKrf9cmyg) (tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* topLevelStmt);
typedef N_NIMCALL_PTR(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, tyProc__EAEKmBUgKFg29agoUGtzDEQ) (tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
struct tyTuple__4o9cW9aUwdGqgZI9bSHHYnbaQ {
tyProc__jkSFMhvPZ1AdGcvT2dK9a2w Field0;
tyProc__A7Sdoem70tRxSEmKrf9cmyg Field1;
tyProc__EAEKmBUgKFg29agoUGtzDEQ Field2;
NIM_BOOL Field3;
};
struct tyTuple__z822nu9bFF1AlQnLrHjdwpA {
tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q Field0;
NimStringDesc* Field1;
};
struct tyObject_TFileInfo__GE3hAakXKOEpch4ap3zXAw {
NimStringDesc* fullPath;
NimStringDesc* projPath;
NimStringDesc* shortName;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* quotedName;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* quotedFullName;
tySequence__sM4lkSb7zS6F7OVMvW9cffQ* lines;
NimStringDesc* dirtyFile;
NimStringDesc* hash;
NIM_BOOL dirty;
};
struct tyTuple__QeWl6B6ffS4pU6WWrtcrDw {
NI Field0;
NimStringDesc* Field1;
};
typedef NU8 tySet_tyEnum_CfileFlag__Vl9c9ayddDuXiWtnWTsEYGsA;
struct tyObject_Cfile__i9cKq1ZGd1wgagjUEHLVFtg {
NimStringDesc* nimname;
NimStringDesc* cname;
NimStringDesc* obj;
tySet_tyEnum_CfileFlag__Vl9c9ayddDuXiWtnWTsEYGsA flags;
NimStringDesc* customArgs;
};
struct tyTuple__awOivLjlO76sGdHY7nQUjQ {
NI Field0;
NI Field1;
NimStringDesc* Field2;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* Field3;
};
struct tyTuple__0q9cmhneJEKnQERTpXXdz6Q {
NU32 Field0;
NimStringDesc* Field1;
};
struct tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg {
NU16 line;
NI16 col;
NU32 file;
};
struct tyObject_PackedNode__7lDGAZiNp4zbO65GEpoKow {
tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw kind;
tySet_tyEnum_TNodeFlag__jyh9acXHkhZANSSvPIY7ZLg flags;
NI32 operand;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ typeId_0;
tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg info;
};
struct tyTuple__Izx9aRSX9a0diDXD84jOS9aMQ {
NU32 Field0;
NI32 Field1;
};
struct tyTuple__Q7r9caOmeWqQGZCIBHhGRUA {
NU32 Field0;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field1;
};
struct tyTuple__7Wlwbz8zSe7Udyf7mmsd9cg {
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field0;
tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg Field1;
};
struct tyTuple__XyJ8LOAZzVVXSsmt09b8uWw {
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field0;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field1;
};
struct tyObject_PackedInstantiation__39cWRURu69agjI9c1ohiUmxiA {
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ key;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ sym;
tySequence__vC9cvg0R8tfBaOXXi3sfMzw* concreteTypes;
};
typedef NU8 tyEnum_TTypeAttachedOp__Rp5P9bWYldQTLkZ7DytmxOg;
struct tyTuple__9aoobCDZB4x41HJSOmh0mwA {
tyEnum_TTypeAttachedOp__Rp5P9bWYldQTLkZ7DytmxOg Field0;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field1;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field2;
};
struct tyTuple__g0Q6Qx15nK53ce9aLo7YyrA {
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field0;
NI Field1;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ Field2;
};
typedef NU8 tyEnum_TLibKind__9b8v60kso59bBaw9cp8B9a9apKQ;
struct tyObject_PackedLib__oa01YzfeXO9bbIDH9cIki4Hw {
tyEnum_TLibKind__9b8v60kso59bBaw9cp8B9a9apKQ kind;
NIM_BOOL generated;
NIM_BOOL isOverriden;
NU32 name;
NI32 path;
};
struct tyObject_PackedSym__XjVn21MwvH8ij6CfopYZWw {
tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw kind;
NU32 name;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ typ;
tySet_tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw flags;
tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg magic;
tyObject_PackedLineInfo__Q9bbXLBurHo2r5TyF6UBshg info;
NI32 ast;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ owner;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ guard;
NI bitsize;
NI alignment;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options;
NI position;
NI offset;
NU32 externalName;
tySet_tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA locFlags;
tyObject_PackedLib__oa01YzfeXO9bbIDH9cIki4Hw annex;
NI32 constraint;
};
struct tyObject_PackedType__IhXsK7mrwumUBtEqbZ2BqA {
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag kind;
tyEnum_TCallingConvention__yjAJ8w0h1PBaSwSGJ3P7IA callConv;
tySet_tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw flags;
tySequence__vC9cvg0R8tfBaOXXi3sfMzw* types;
NI32 n;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ sym;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ owner;
NI64 size;
NI16 align;
NI16 paddingAtEnd;
NI16 lockLevel;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ typeInst;
NI32 nonUniqueId;
};
struct tyTuple__8x6vq4Dc9aLvKX9actMeR9avQ {
NI Field0;
tyObject_TIdent__1LTsGP7bSxg45u9aHcxh6OA* Field1;
tySequence__vC9cvg0R8tfBaOXXi3sfMzw* Field2;
};
struct tyTuple__UvldbCB6B9ayi9bGYW7vJNLA {
NI Field0;
NI32 Field1;
NU32 Field2;
};
struct tySequence__eHqUwlHGGaPw0TDPDeL79cQ {
TGenericSeq Sup;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* data[SEQ_DECL_SIZE];
};
struct tySequence__8fytVdU59b5aj319cog2ztLw {
TGenericSeq Sup;
tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg data[SEQ_DECL_SIZE];
};
struct tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ {
TGenericSeq Sup;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* data[SEQ_DECL_SIZE];
};
struct tySequence__XUL1TrMU0tgXmaMFCIYgFQ {
TGenericSeq Sup;
tyTuple__tA7Q8IrfOKH7Mn89cK9cBAIg data[SEQ_DECL_SIZE];
};
struct tySequence__4mZLwkxT8rbt9bf3wXrXYNQ {
TGenericSeq Sup;
tyObject_Iface__uvkV248cZcsEQKaQm7C9aEA data[SEQ_DECL_SIZE];
};
struct tySequence__rQHmYk1HzcwNxKBymIFHpA {
TGenericSeq Sup;
tyObject_LoadedModule__14iJKkvOiWT62KF2D8f9c5w data[SEQ_DECL_SIZE];
};
struct tySequence__XMM60DtBsc6xYsIpNANkrA {
TGenericSeq Sup;
tyObject_PackedEncoder__B9cE9a0GbvqWW9aHf4N7RAaIw data[SEQ_DECL_SIZE];
};
struct tySequence__O5RcspOP32YJ4YtU5ppxxA {
TGenericSeq Sup;
tyObject_LazyType__Q19c34D32PKyTKlx6R6yODg data[SEQ_DECL_SIZE];
};
struct tySequence__ChDZ6dokJ9aj9cg3KBoCU5vg {
TGenericSeq Sup;
tyTuple__l7R9cf53SDCcRmz9aWTyEKqQ data[SEQ_DECL_SIZE];
};
struct tySequence__Or1y9bNpmj8PM8AcK9c9cg7RA {
TGenericSeq Sup;
tyObject_LazyInstantiation__rlce0Sj8mBfLfm69c2yVTZg data[SEQ_DECL_SIZE];
};
struct tySequence__mWRMiYLthG9coLjkbElCxkw {
TGenericSeq Sup;
tyTuple__o67sDX0wYbEuhI9cJYAbDtg data[SEQ_DECL_SIZE];
};
struct tySequence__bTDCDwD2P7TodzbAefLcSw {
TGenericSeq Sup;
tyTuple__9aNnDWBFMF44sfFinBpMT4Q data[SEQ_DECL_SIZE];
};
struct tySequence__159bHWBGAOOs6U7OZ9cQlO0g {
TGenericSeq Sup;
tyTuple__VrD6plbUKJjYKM0lCr3hGQ data[SEQ_DECL_SIZE];
};
struct tySequence__3MPVXAHA08SszBrU4ffqEg {
TGenericSeq Sup;
tyTuple__dT8l9anHpNRgQSBAI9ctQ2wg data[SEQ_DECL_SIZE];
};
struct tySequence__YCf5zJHm4JI06qpmKwPUWg {
TGenericSeq Sup;
tyTuple__1ZbjBgxAbnye0IFMZ6w4OA data[SEQ_DECL_SIZE];
};
struct tySequence__7lEisrXlQEzwtUKW5pzRCw {
TGenericSeq Sup;
tyTuple__xYhUhS7X82rKTqbT9bRfCnw data[SEQ_DECL_SIZE];
};
struct tySequence__61s9cbAniKuBrdHwBhMDfQg {
TGenericSeq Sup;
tyTuple__rplX06U9bjhu9asm5pWdgqsA data[SEQ_DECL_SIZE];
};
struct tySequence__Bre9bNyuQOg1EJKitjSzn8w {
TGenericSeq Sup;
tyObject_TrunkcolonObjectType___POcWT53G7t0BSUjc31o0iA* data[SEQ_DECL_SIZE];
};
struct tySequence__48JTohSgTy339bRxHzUD8KA {
TGenericSeq Sup;
NI32 data[SEQ_DECL_SIZE];
};
struct tySequence__fdmz6VkIf1ewwrssKYqRFg {
TGenericSeq Sup;
tyTuple__1mtQ8sCEE7DbfIuQciv9b5Q data[SEQ_DECL_SIZE];
};
struct tySequence__kxu4GK0onha2t9bo86mdVAg {
TGenericSeq Sup;
tyTuple__xDU9bZmv1ZbZkJDaATBekIQ data[SEQ_DECL_SIZE];
};
struct tySequence__s9byh6WFJ16lPMcmqdaMTHA {
TGenericSeq Sup;
tyTuple__a9bBCAQ2tegdUQVlHYxdJ2A data[SEQ_DECL_SIZE];
};
struct tySequence__1U9bG8RcAedEeYkQLZjVFKA {
TGenericSeq Sup;
tyTuple__3i6hlQmqrn6m7tuVN8FHjQ data[SEQ_DECL_SIZE];
};
struct tySequence__fIB1rTQ55aFonoft9a9bmljQ {
TGenericSeq Sup;
tyTuple__OJFzEczluV8Jmo9bRpBfkzw data[SEQ_DECL_SIZE];
};
struct tySequence__23SMqauuRsbDANhthj9bWlA {
TGenericSeq Sup;
tyTuple__2SGm9aGCXuo7XSQ9bqD29axXw data[SEQ_DECL_SIZE];
};
struct tySequence__squ9b9bUH4OLHf6cEMrt6hVA {
TGenericSeq Sup;
tyTuple__F3gkSrMB1qp2Tvf9bixVXwg data[SEQ_DECL_SIZE];
};
struct tySequence__pHNq3oXj9av2sEUdqaqeZjw {
TGenericSeq Sup;
tyTuple__wcNatyuf8WOqAhGLhSvgiw data[SEQ_DECL_SIZE];
};
struct tySequence__MAQKEADohlpnXTModtugbQ {
TGenericSeq Sup;
tyTuple__4o9cW9aUwdGqgZI9bSHHYnbaQ data[SEQ_DECL_SIZE];
};
struct tySequence__tNFrR3kRuS1FSwuiLGoSSA {
TGenericSeq Sup;
tyTuple__z822nu9bFF1AlQnLrHjdwpA data[SEQ_DECL_SIZE];
};
struct tySequence__Zi9cGbCWofbtABoHJ5RbLNQ {
TGenericSeq Sup;
tyObject_TFileInfo__GE3hAakXKOEpch4ap3zXAw data[SEQ_DECL_SIZE];
};
struct tySequence__4eRCaZmrYLLw2k30GPTiMw {
TGenericSeq Sup;
tyTuple__QeWl6B6ffS4pU6WWrtcrDw data[SEQ_DECL_SIZE];
};
struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ {
TGenericSeq Sup;
NimStringDesc* data[SEQ_DECL_SIZE];
};
struct tySequence__pK3qSsBZwdXd6qyUMkd5Jw {
TGenericSeq Sup;
tyObject_Cfile__i9cKq1ZGd1wgagjUEHLVFtg data[SEQ_DECL_SIZE];
};
struct tySequence__9aZVGG5Gtti9cC9bqRpXCtA3A {
TGenericSeq Sup;
tyObject_TType__facALICuu8zUj0hjvbTLFg* data[SEQ_DECL_SIZE];
};
struct tySequence__MlAD6nAPq9bHKla9cWiIZP0g {
TGenericSeq Sup;
tyTuple__awOivLjlO76sGdHY7nQUjQ data[SEQ_DECL_SIZE];
};
struct tySequence__oLpBKXzW3hF9aCVMo5EymfQ {
TGenericSeq Sup;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* data[SEQ_DECL_SIZE];
};
struct tySequence__vv5mGmK03BCr5e3LTZA5Hw {
TGenericSeq Sup;
tyObject_LazySym__rhF4Xi6CELPmWy539c1l6fA data[SEQ_DECL_SIZE];
};
struct tySequence__PXIzfWocnrafGz5p3CP5LA {
TGenericSeq Sup;
tyTuple__0q9cmhneJEKnQERTpXXdz6Q data[SEQ_DECL_SIZE];
};
struct tySequence__9bAGqSvkAaFL9bWjsEPslrFA {
TGenericSeq Sup;
NU32 data[SEQ_DECL_SIZE];
};
struct tySequence__29bS0n2QNyO1R7e0qMMOvLA {
TGenericSeq Sup;
tyObject_PackedNode__7lDGAZiNp4zbO65GEpoKow data[SEQ_DECL_SIZE];
};
struct tySequence__b89aLriiJnVTD186H6zNIgg {
TGenericSeq Sup;
tyTuple__Izx9aRSX9a0diDXD84jOS9aMQ data[SEQ_DECL_SIZE];
};
struct tySequence__REuPuHuSlOkZ0Q5oqzDrQg {
TGenericSeq Sup;
tyTuple__Q7r9caOmeWqQGZCIBHhGRUA data[SEQ_DECL_SIZE];
};
struct tySequence__I9aQmO9asXXWJ58UI9c8BCSzA {
TGenericSeq Sup;
tyTuple__7Wlwbz8zSe7Udyf7mmsd9cg data[SEQ_DECL_SIZE];
};
struct tySequence__NyaOkf8ZwxP6rkRF5TOkew {
TGenericSeq Sup;
tyTuple__XyJ8LOAZzVVXSsmt09b8uWw data[SEQ_DECL_SIZE];
};
struct tySequence__L9bOt8CaTEmIjgtuZvp6syg {
TGenericSeq Sup;
tyObject_PackedInstantiation__39cWRURu69agjI9c1ohiUmxiA data[SEQ_DECL_SIZE];
};
struct tySequence__im8UB2GsZvUaQ4a1wKGWhQ {
TGenericSeq Sup;
tyTuple__9aoobCDZB4x41HJSOmh0mwA data[SEQ_DECL_SIZE];
};
struct tySequence__xxnXDLpoqBo8zJzP9b1073g {
TGenericSeq Sup;
tyTuple__g0Q6Qx15nK53ce9aLo7YyrA data[SEQ_DECL_SIZE];
};
struct tySequence__DfmUmNgVGnYaiV1I6227tw {
TGenericSeq Sup;
tyObject_PackedSym__XjVn21MwvH8ij6CfopYZWw data[SEQ_DECL_SIZE];
};
struct tySequence__t8Uv4lEJ4lkuECvP9c6JMhA {
TGenericSeq Sup;
tyObject_PackedType__IhXsK7mrwumUBtEqbZ2BqA data[SEQ_DECL_SIZE];
};
struct tySequence__IHUFRsFxZNv7YydiUO2esQ {
TGenericSeq Sup;
NI64 data[SEQ_DECL_SIZE];
};
struct tySequence__vC9cvg0R8tfBaOXXi3sfMzw {
TGenericSeq Sup;
tyObject_PackedItemId__FzcXUzSZ9cNfGYsfibgjWlQ data[SEQ_DECL_SIZE];
};
struct tySequence__9bT7o0CflHuiE4VhmtqBPCw {
TGenericSeq Sup;
tyTuple__8x6vq4Dc9aLvKX9actMeR9avQ data[SEQ_DECL_SIZE];
};
struct tySequence__9cnx3zXnWzeclW8Ko4oUgAQ {
TGenericSeq Sup;
tyTuple__UvldbCB6B9ayi9bGYW7vJNLA data[SEQ_DECL_SIZE];
};
struct tySequence__ipEvhpHAmm8ZCn9bZAOdNYA {
TGenericSeq Sup;
tyObject_FullId__pfGm9bmVgXcP2kl6OfHhZgQ data[SEQ_DECL_SIZE];
};
N_LIB_PRIVATE N_NIMCALL(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*, newModule__jsgen_6499)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module);
N_LIB_PRIVATE N_NIMCALL(void, nimGCvisit)(void* d, NI op);
static N_NIMCALL(void, Marker_tyRef__O09bHTFgtn9cJLLJxiNhuKUA)(void* p, NI op);
N_LIB_PRIVATE N_NOINLINE(void*, newObj)(TNimType* typ, NI size);
static N_INLINE(void, asgnRef)(void** dest, void* src);
static N_INLINE(void, incRef__system_5338)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c);
static N_INLINE(NI, pluspercent___system_696)(NI x, NI y);
static N_INLINE(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*, usrToCell__system_5300)(void* usr);
static N_INLINE(NI, minuspercent___system_716)(NI x, NI y);
static N_INLINE(void, decRef__system_5345)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c);
static N_INLINE(NIM_BOOL, ltpercent___system_1005)(NI x, NI y);
static N_INLINE(void, rtlAddZCT__system_5343)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c);
N_LIB_PRIVATE N_NOINLINE(void, addZCT__system_5294)(tyObject_CellSeq__Axo1XVm9aaQueTOldv8le5w* s, tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c);
N_LIB_PRIVATE N_NIMCALL(void, initCountTable__cgen_28210)(NI initialSize, tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ* Result);
N_LIB_PRIVATE N_NIMCALL(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*, newGlobals__jsgen_141)(void);
static N_NIMCALL(void, Marker_tyRef__Q8XTeJJ39cPFyNvJXj9bmcMQ)(void* p, NI op);
static N_INLINE(void, nimGCunrefRC1)(void* p);
static N_INLINE(void, initIntSet__pureZcollectionsZintsets_238)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* Result);
N_LIB_PRIVATE N_NIMCALL(void, initPackedSet__pureZcollectionsZintsets_16)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* Result);
static N_INLINE(NIM_BOOL, skipCodegen__passes_49)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, internalErrorImpl__msgs_1431)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info, NimStringDesc* errMsg, tyTuple__kN8up2W6YKc5YA9avn5mV5w info2);
N_LIB_PRIVATE N_NIMCALL(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*, newInitProc__jsgen_244)(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module);
N_LIB_PRIVATE N_NIMCALL(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*, newProc__jsgen_200)(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* procDef, tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options);
static N_NIMCALL(void, Marker_tySequence__8fytVdU59b5aj319cog2ztLw)(void* p, NI op);
static N_NIMCALL(void, Marker_tyRef__OFWibP8T8afo89apFNGZiwA)(void* p, NI op);
N_LIB_PRIVATE N_NIMCALL(tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg, initProcOptions__jsgen_237)(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module);
static N_INLINE(void, nimZeroMem)(void* p, NI size);
static N_INLINE(void, nimSetMem__systemZmemory_7)(void* a, int v, NI size);
N_LIB_PRIVATE N_NIMCALL(void, genModule__jsgen_6560)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, add__ropes_159)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** a, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, frameCreate__jsgen_5821)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* procname, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* filename);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, indentLine__jsgen_97)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* r);
N_LIB_PRIVATE N_NIMCALL(void, prepend__ropes_265)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** a, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rope__ropes_109)(NimStringDesc* s);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5827)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, runtimeFormat__ropes_271)(NimStringDesc* frmt, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5832)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, makeJSString__jsgen_378)(NimStringDesc* s, NIM_BOOL escapeNonAscii);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, nsuEscape)(NimStringDesc* s, NimStringDesc* prefix, NimStringDesc* suffix);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, escapeJSString__jsgen_370)(NimStringDesc* s);
N_NIMCALL(NimStringDesc*, rawNewString)(NI cap);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
static N_INLINE(void, copyMem__system_1727)(void* dest, void* source, NI size);
static N_INLINE(void, nimCopyMem)(void* dest, void* source, NI size);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, resizeString)(NimStringDesc* dest, NI addlen);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, addChar)(NimStringDesc* s, NIM_CHAR c);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, toFilenameOption__msgs_590)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, NI32 fileIdx, tyEnum_FilenameOption__eL86bAtPxXWHj24F5gOMFQ opt);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, transformStmt__transf_1873)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, injectDestructorCalls__injectdestructors_10100)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* owner, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, hcrOn__options_569)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, amp___ropes_128)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, amp___ropes_140)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a, NimStringDesc* b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, idOrSig__sighashes_2057)(tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s, NimStringDesc* currentModule, tyObject_CountTable__tUMxxU9cRgLolsrW9b7IBGsQ* sigCollisions);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_851)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, addHcrInitGuards__jsgen_6528)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* moduleLoadedVar, NIM_BOOL* inInitGuard);
static N_INLINE(NI, safeLen__ast_3191)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
static N_INLINE(NI, len__ast_3198)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6551)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genStmt__jsgen_770)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, gen__jsgen_766)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_LIB_PRIVATE N_NIMCALL(void, genSym__jsgen_3308)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genVarInit__jsgen_3304)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* v, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, mangleName__jsgen_308)(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, validJsName__jsgen_312)(NimStringDesc* name);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
static N_INLINE(NIM_BOOL, equalMem__system_1735)(void* a, void* b, NI size);
static N_INLINE(int, nimCmpMem)(void* a, void* b, NI size);
N_LIB_PRIVATE N_NIMCALL(NI, hashString)(NimStringDesc* s);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, mangle__ccgutils_112)(NimStringDesc* name);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, toHex__pureZstrutils_1792)(NI x, NI len);
N_LIB_PRIVATE N_NIMCALL(void, add__ropes_162)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** a, NimStringDesc* b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rope__ropes_115)(NI64 i);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4072)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___ropes_250)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4081)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_LIB_PRIVATE N_NIMCALL(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA, mapType__jsgen_304)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
N_LIB_PRIVATE N_NIMCALL(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA, mapType__jsgen_277)(tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
N_LIB_PRIVATE N_NIMCALL(tyObject_TType__facALICuu8zUj0hjvbTLFg*, skipTypes__ast_3735)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t, tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag kinds);
N_LIB_PRIVATE N_NIMCALL(tyObject_TType__facALICuu8zUj0hjvbTLFg*, lastSon__ast_3743)(tyObject_TType__facALICuu8zUj0hjvbTLFg* n);
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__systemZassertions_56)(NimStringDesc* msg);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4124)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4129)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1262)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, createVar__jsgen_3791)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, NIM_BOOL indirect);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, putToSeq__jsgen_3782)(NimStringDesc* s, NIM_BOOL indirect);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3786)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NI, toInt__int495056_170)(tyObject_Int128__9a9axPfb75jdWY25AamJewkA arg);
N_LIB_PRIVATE N_NIMCALL(tyObject_Int128__9a9axPfb75jdWY25AamJewkA, lengthOrd__types_1661)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(tyObject_TType__facALICuu8zUj0hjvbTLFg*, elemType__types_263)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, arrayTypeForElemType__jsgen_3959)(tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3974)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, useMagic__jsgen_779)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, NimStringDesc* name);
N_LIB_PRIVATE N_NIMCALL(tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*, getCompilerProc__magicsys_145)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, NimStringDesc* name);
static N_INLINE(NimStringDesc*, toFileLineCol__msgs_615)(tyTuple__kN8up2W6YKc5YA9avn5mV5w info);
static N_INLINE(void, addInt__stdZprivateZdigitsutils_189)(NimStringDesc** result, NI x);
N_LIB_PRIVATE N_NIMCALL(void, addInt__stdZprivateZdigitsutils_167)(NimStringDesc** result, NI64 x);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, containsOrIncl__astalgo_402)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* s, NI key);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genProc__jsgen_773)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* oldProc, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, generateHeader__jsgen_2418)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
static N_INLINE(NIM_BOOL, isCompileTimeOnly__types_3528)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5921)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5926)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5954)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5964)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5969)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, transformBody__transf_16)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc, NIM_BOOL cache);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, lineDir__jsgen_1808)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info, NI line);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1813)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, toFullPath__msgs_538)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, NI32 fileIdx);
static N_INLINE(NI, toLinenumber__msgs_609)(tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, optionalLine__jsgen_5862)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* p);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genProcBody__jsgen_5840)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, hasFrameInfo__jsgen_1789)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p);
static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5844)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2287)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5857)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, frameDestroy__jsgen_5837)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6000)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6005)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_7505)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NOINLINE(void, liMessage__msgs_1118)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info, tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w msg, NimStringDesc* arg, tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw eh, tyTuple__kN8up2W6YKc5YA9avn5mV5w info2, NIM_BOOL isRaw);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3979)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genTypeInfo__jsgen_385)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_689)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_719)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_505)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_543)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genEnumInfo__jsgen_606)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_631)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_645)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_528)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genObjectInfo__jsgen_497)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name);
static N_INLINE(NIM_BOOL, objHasTypeField__jsgen_485)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_517)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genObjectFields__jsgen_388)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_413)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_418)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_462)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rope__jsgen_382)(tyObject_Int128__9a9axPfb75jdWY25AamJewkA arg);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___int495056_53)(tyObject_Int128__9a9axPfb75jdWY25AamJewkA a);
N_LIB_PRIVATE N_NIMCALL(tyObject_Int128__9a9axPfb75jdWY25AamJewkA, getOrdValue__types_161)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_Int128__9a9axPfb75jdWY25AamJewkA onError);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_475)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, lastSon__ast_4832)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_480)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genTupleInfo__jsgen_574)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genTupleFields__jsgen_548)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ);
static N_INLINE(NI, len__ast_4002)(tyObject_TType__facALICuu8zUj0hjvbTLFg* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_562)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, reprEnum)(NI e, TNimType* typ);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4002)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, createObjInitList__jsgen_3943)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* excludedFieldIDs, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** output);
N_LIB_PRIVATE N_NIMCALL(NI, len__ropes_10)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3949)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, createRecordVarAux__jsgen_3795)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* rec, tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* excludedFieldIDs, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** output);
static N_INLINE(NIM_BOOL, isEmptyType__ast_4779)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, contains__astalgo_3496)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* s, NI key);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3938)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4012)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, needsNoCopy__jsgen_2483)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* y);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4160)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, getTemp__jsgen_838)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, NIM_BOOL defineInLocals);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_846)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4213)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, newNodeI__ast_3356)(tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw kind, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info);
N_LIB_PRIVATE N_NIMCALL(void, genCopyForParamIfNeeded__jsgen_3260)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3298)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3364)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3369)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2827)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2822)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genConstant__jsgen_776)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* c);
static N_INLINE(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, getBody__modulegraphs_11241)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, loadProcBody__icZic_8390)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_IdentCachecolonObjectType___TzLHS09bRH9a0TYLs39cqcNaw* cache, tySequence__rQHmYk1HzcwNxKBymIFHpA** g, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(TGenericSeq*, incrSeqV3)(TGenericSeq* s, TNimType* typ);
N_LIB_PRIVATE N_NIMCALL(void, genProcForSymIfNeeded__jsgen_3222)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(void, attachProc__jsgen_3214)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* content, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6385)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA, classify__pureZmath_147)(NF x);
static N_INLINE(NIM_BOOL, signbit__astalgo_926)(NF x);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, toStrMaxPrecision__astalgo_920)(NF f);
N_LIB_PRIVATE N_NIMCALL(void, genLineDir__jsgen_1818)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19262)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1834)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genMagic__jsgen_4598)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genOr__jsgen_903)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* a, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, isSimpleExpr__jsgen_821)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
static N_INLINE(NIM_BOOL, isAtom__ast_4768)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_917)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
static N_INLINE(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rdLoc__jsgen_188)(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* a);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_6775)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_922)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_885)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genAnd__jsgen_856)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* a, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_871)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_876)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, arith__jsgen_1716)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg op);
N_LIB_PRIVATE N_NIMCALL(void, binaryUintExpr__jsgen_1721)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* op);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, unsignedTrimmerJS__jsgen_1101)(NI64 size);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1734)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1761)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, arithAux__jsgen_1135)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg op);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1163)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1168)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1173)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1178)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1183)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1188)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1193)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1198)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1203)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1208)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1253)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1272)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1281)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1291)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1300)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1309)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1318)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1327)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1336)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1345)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1386)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19065)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19070)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19075)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19153)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1579)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_18935)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1588)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1597)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1602)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_19257)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1615)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1624)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1649)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1658)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1667)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1684)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1770)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1784)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genRepr__jsgen_4500)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genReprAux__jsgen_4482)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* magic, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* typ);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_11991)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genSwap__jsgen_2717)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2739)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2744)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4625)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, maybeMakeTemp__jsgen_964)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* x, tyTuple__nsNHL3sm0TZE9bootw2pEXw* Result);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, needsTemp__jsgen_951)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_985)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_993)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4642)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4650)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4669)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4681)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genConStrStr__jsgen_4413)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4424)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4429)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4448)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4453)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4472)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4477)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4704)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4723)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4742)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, contains__pureZstrutils_1631)(NimStringDesc* s, NimStringDesc* sub);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4759)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4766)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genNew__jsgen_4346)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1950)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4366)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4371)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genJSArrayConstr__jsgen_4569)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genOrd__jsgen_4391)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4408)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4794)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4799)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4814)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4819)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, binaryUintExpr__jsgen_4829)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* op);
N_LIB_PRIVATE N_NIMCALL(void, maybeMakeTempAssignable__jsgen_1002)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* x, tyTuple__nsNHL3sm0TZE9bootw2pEXw* Result);
N_LIB_PRIVATE N_NIMCALL(tyObject_Int128__9a9axPfb75jdWY25AamJewkA, firstOrd__types_1353)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, tyObject_TType__facALICuu8zUj0hjvbTLFg* t);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, eqeq___int495056_759)(tyObject_Int128__9a9axPfb75jdWY25AamJewkA a, NI64 b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1056)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1061)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1066)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4845)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4868)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4889)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4924)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4945)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4964)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4982)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4994)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5013)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5032)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5051)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5070)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5089)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5108)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5127)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5146)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5165)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genNewSeq__jsgen_4376)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4386)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5177)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genOf__jsgen_4506)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4522)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4527)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genDefault__jsgen_4532)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genReset__jsgen_4536)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4545)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4554)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genEcho__jsgen_3758)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, skipConv__types_3597)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, genArgNoParam__jsgen_3485)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, nsuFormatSingleElem)(NimStringDesc* formatstr, NimStringDesc* a);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5190)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5202)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genCall__jsgen_3735)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genArgs__jsgen_3551)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NI start);
N_LIB_PRIVATE N_NIMCALL(void, genArg__jsgen_3494)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* param, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NI* emitted);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3538)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2817)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5214)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genMove__jsgen_4559)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genInfixCall__jsgen_3688)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, contains__pureZstrutils_1635)(NimStringDesc* s, tySet_tyChar__nmiMWKVIe46vacnhAFrQvw chars);
N_LIB_PRIVATE N_NIMCALL(void, genPatternCall__jsgen_3641)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, NimStringDesc* pat, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genOtherArg__jsgen_3606)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, NI i, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, NI* generated, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___systemZdollars_3)(NI x);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, substr__system_7773)(NimStringDesc* s, NI first, NI last);
N_LIB_PRIVATE N_NIMCALL(void, genSetConstr__jsgen_5219)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, isDeepConstExpr__trees_171)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, NIM_BOOL preventInheritance);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2940)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genArrayConstr__jsgen_5263)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5275)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genTupleConstr__jsgen_5289)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5314)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5323)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genObjConstr__jsgen_5328)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, incl__pureZcollectionsZintsets_55)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* s, NI key);
N_LIB_PRIVATE N_NIMCALL(tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*, lookupFieldAgain__types_4062)(tyObject_TType__facALICuu8zUj0hjvbTLFg* ty, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* field);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5414)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5423)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5433)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genConv__jsgen_5438)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
static N_INLINE(NIM_BOOL, contains__semfold_938)(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA s, tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag value);
static N_INLINE(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA, dotdot___semfold_916)(tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag a, tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag b);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5711)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5720)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5725)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genAddr__jsgen_2875)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___jsgen_3124)(tyTuple__Fb1Z8PVtzpSjrvQ67oA88w x);
N_LIB_PRIVATE N_NIMCALL(void, addQuoted__pureZos_431)(NimStringDesc** s, NimStringDesc* x);
N_LIB_PRIVATE N_NIMCALL(void, addQuoted__jsgen_3158)(NimStringDesc** s, tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw x);
N_LIB_PRIVATE N_NIMCALL(void, genCheckedFieldOp__jsgen_2879)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TType__facALICuu8zUj0hjvbTLFg* addrTyp, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, genFieldDefect__astmsgs_61)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf, NimStringDesc* field, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* disc);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2956)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2946)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2951)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_7439)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genFieldAddr__jsgen_2753)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(NI, getFieldPosition__jsgen_2749)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* f);
N_LIB_PRIVATE N_NIMCALL(void, genFieldAccess__jsgen_2791)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_13309)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genArrayAddr__jsgen_2973)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genDeref__jsgen_3452)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genArrayAccess__jsgen_3014)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3038)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, upConv__jsgen_5730)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genCast__jsgen_6047)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6324)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6331)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6348)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genRangeChck__jsgen_5735)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* magic);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5757)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, convStrToCStr__jsgen_5762)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5778)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, convCStrToStr__jsgen_5783)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(void, genBlock__jsgen_2248)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2273)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(TGenericSeq*, setLengthSeqV2)(TGenericSeq* s, TNimType* typ, NI newLen);
N_LIB_PRIVATE N_NIMCALL(void, genIf__jsgen_2358)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2012)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2395)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, moveInto__jsgen_1938)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* src, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* dest);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_7770)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, nsuRepeatChar)(NIM_CHAR c, NI count);
N_LIB_PRIVATE N_NIMCALL(void, genWhileStmt__jsgen_1839)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
static N_INLINE(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg*, X5BX5D___jsgen_1858)(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg* s, NI sLen_0, NI i);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1881)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1895)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genVarStmt__jsgen_4260)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, lowerTupleUnpacking__lowerings_116)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* owner);
N_LIB_PRIVATE N_NIMCALL(void, genCaseJS__jsgen_2140)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2154)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_13684)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, copyNode__ast_4336)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* src);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_15312)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_7416)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2226)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genReturnStmt__jsgen_5803)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5816)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genBreakStmt__jsgen_2292)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2325)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genAsgn__jsgen_2701)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, genAsgnAux__jsgen_2511)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* x, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* y, NIM_BOOL noCopyNeeded);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2539)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2561)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2566)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2584)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2593)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2610)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___jsgen_2635)(tyTuple__QVkyTCL0msoEdWvhK6TYrw x);
N_LIB_PRIVATE N_NIMCALL(void, addQuoted__jsgen_2669)(NimStringDesc** s, tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA x);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2692)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genFastAsgn__jsgen_2706)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, amp___ropes_144)(NimStringDesc* a, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b);
N_LIB_PRIVATE N_NIMCALL(void, genAsmOrEmitStmt__jsgen_2330)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, genTry__jsgen_1959)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1982)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1990)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1995)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, isInfixAs__ast_4935)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, isImportedException__ast_4904)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t, tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2057)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2062)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2067)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2076)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2095)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genRaiseStmt__jsgen_2123)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2135)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(void, genPragma__jsgen_6039)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyEnum_TSpecialWord__ycbpMCRV6Cd2eBh3X9biEiw, whichPragma__trees_244)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___cgen_13931)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6587)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, myProcess__jsgen_6596)(tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* b, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n);
N_LIB_PRIVATE N_NIMCALL(void, add__ast_4797)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* father, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* son);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genHeader__jsgen_6526)(void);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, nsuFormatVarargs)(NimStringDesc* formatstr, NimStringDesc** a, NI aLen_0);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, nsuUnindent)(NimStringDesc* s, NI count, NimStringDesc* padding);
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, wholeCode__jsgen_6607)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m);
N_LIB_PRIVATE N_NIMCALL(void, attachProc__jsgen_3218)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s);
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, generateMethodDispatchers__cgmeth_546)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, prepareToWriteOutput__options_4058)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* conf);
N_LIB_PRIVATE N_NIMCALL(void, genSourceMap__sourcemap_896)(NimStringDesc* source, NimStringDesc* outFile, tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg* Result);
N_LIB_PRIVATE N_NIMCALL(void, writeFile__systemZio_472)(NimStringDesc* filename, NimStringDesc* content);
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___pureZjson_4465)(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* node);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6732)(tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* o);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, newJNull__pureZjson_90)(void);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6739)(tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* o);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, newJObject__pureZjson_92)(void);
static N_INLINE(void, X5BX5Deq___pureZjson_1923)(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* obj, NimStringDesc* key, tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* val);
N_LIB_PRIVATE N_NIMCALL(void, X5BX5Deq___pureZjson_287)(tyObject_OrderedTable__ZZvSdVkA2s2sIyifu4cpkg* t, NimStringDesc* key, tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* val);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___pureZjson_1800)(NI n);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6746)(NimStringDesc** elements, NI elementsLen_0);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, newJArray__pureZjson_123)(void);
N_LIB_PRIVATE N_NIMCALL(void, add__pureZjson_222)(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* father, tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* child);
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___pureZjson_1790)(NimStringDesc* s);
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, writeRopeIfNotEqual__ropes_458)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* r, NimStringDesc* filename);
extern TNimType NTItpasscontext__Hb6rFM0ecvtlLf2kv9aU75w_;
N_LIB_PRIVATE TNimType NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_;
extern TNimType NTIpsym__dG2QVH5Z69aMUY38zTqWxaA_;
extern TNimType NTImodulegraph__KfdHSsl8vyUCSI9b3inBcww_;
extern TNimType NTIconfigref__a8lycfSA25OQltN3OMeBsA_;
extern TNimType NTIcounttable__tUMxxU9cRgLolsrW9b7IBGsQ_;
N_LIB_PRIVATE TNimType NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_;
extern TNimType NTIrootobj__ytyiCJqK439aF9cIibuRVpAg_;
N_LIB_PRIVATE TNimType NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_;
extern TNimType NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_;
extern TNimType NTIseqLpsymT__eHqUwlHGGaPw0TDPDeL79cQ_;
extern TNimType NTIpackedset__IhxwDBRi51nGrosBGFKcsA_;
extern TNimType NTIint__rR5Bzr1D5krxoo1NcNyeMA_;
extern TNimType NTIbool__VaVACK0bpYmqIQ0mKcHfQQ_;
N_LIB_PRIVATE TNimType NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_4, "myProcess", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_6, "/home/runner/work/nightlies/nightlies/nim/compiler/jsgen.nim", 60);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_5 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2714),
((NI) 35)}
;
N_LIB_PRIVATE TNimType NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_;
extern TNimType NTIpnode__fKfcLzXYiz5jNu3NH3Tv8Q_;
extern TNimType NTItoptions__7MnKRybmCNh5j9bDRLMkxLw_;
N_LIB_PRIVATE TNimType NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_;
N_LIB_PRIVATE TNimType NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_;
N_LIB_PRIVATE TNimType NTIpproc__OFWibP8T8afo89apFNGZiwA_;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_9, " ", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_10, "var F = {procname: $1, prev: framePtr, filename: $2, line: 0};$n", 64);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_11, "framePtr = F;$n", 15);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_12, "\"", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_13, "\\n", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_14, "\\r", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_15, "\\t", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_16, "\\b", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_17, "\\a", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_18, "\\e", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_19, "\\v", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_20, "\\\\", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_21, "\\\"", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_22, "module ", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_23, "_loaded", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_24, "var $1;$n", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_25, "}\012", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_26, "if ($1 == undefined) {$n", 24);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_27, "symbol has no generated name: ", 30);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_28 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1399),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_29, "abstract", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_30, "await", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_31, "boolean", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_32, "break", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_33, "byte", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_34, "case", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_35, "catch", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_36, "char", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_37, "class", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_38, "const", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_39, "continue", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_40, "debugger", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_41, "default", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_42, "delete", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_43, "do", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_44, "double", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_45, "else", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_46, "enum", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_47, "export", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_48, "extends", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_49, "false", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_50, "final", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_51, "finally", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_52, "float", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_53, "for", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_54, "function", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_55, "goto", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_56, "if", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_57, "implements", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_58, "import", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_59, "in", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_60, "instanceof", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_61, "int", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_62, "interface", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_63, "let", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_64, "long", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_65, "native", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_66, "new", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_67, "null", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_68, "package", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_69, "private", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_70, "protected", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_71, "public", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_72, "return", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_73, "short", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_74, "static", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_75, "super", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_76, "switch", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_77, "synchronized", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_78, "this", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_79, "throw", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_80, "throws", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_81, "transient", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_82, "true", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_83, "try", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_84, "typeof", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_85, "var", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_86, "void", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_87, "volatile", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_88, "while", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_89, "with", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_90, "yield", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_91, "HEX", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_92, "_", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_93, "if ($1 === undefined) {$n", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_94, "if (globalThis.$1 === undefined) {$n", 36);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_95, "globalThis.", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_96, "var $2", 6);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_97 = {
0x10, 0xa9, 0x00, 0x00, 0x00, 0x60, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_98, "jsgen.nim(212, 38) `false` ", 27);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_99, "var $1 = null;$n", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_100, "var $1_Idx = 0;$n", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_101, " = $3;$n", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_102, "bigint", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_103, "[$1]", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_104, "0n", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_105, "0", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_106, "0.0", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_107, "{}", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_108, "Int32Array", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_109, "Int16Array", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_110, "Int8Array", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_111, "Uint32Array", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_112, "Uint16Array", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_113, "Uint8Array", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_114, "Float32Array", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_115, "Float64Array", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_116, "new $1($2)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_117, "(", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_118, ", ", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_119, ")", 1);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_120 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 301),
((NI) 19)}
;
extern NIM_CONST tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q unknownLineInfo__lineinfos_280;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_121, "_Idx", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_122, "var $# = null;$n", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_123, "var $#_Idx = 0;$n", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_124, "var $# = $#;$n", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_125, "return [$#, $#];$n", 18);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_126, "return $#;$n", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_127, "/* line $2 \"$1\" */$n", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_128, " {$n$#$#$#$#$#", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_129, "\012", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_130, "BeforeRet: do {$n", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_131, "} while (false);$n", 18);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_132, "try {$n$1} catch (e) {$n alert(\"Unhandled exception:\\n\" + e.message + \"\\n\"$n}", 77);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_133, "framePtr = F.prev;\012", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_134, "IMLP", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_135, "\012function $#() { return $#.apply(this, arguments); }$n", 54);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_136, "\012function $#($#) {$n$#$#$#$#$#", 30);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_137, "system module needs: ", 21);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_138 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 307),
((NI) 17)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_139 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 309),
((NI) 16)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_140, "arrayConstr", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_141, "nimCopy", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_142, "arrayConstr($1, $2, $3)", 23);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_143 = {
0x10, 0x28, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_144, "NTI$1", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_145, "var $1 = {size: 0,kind: $2,base: null,node: null,finalizer: null};$n", 68);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_146, "var $1 = {size: 0, kind: $2, base: null, node: null, finalizer: null};$n", 72);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_147, "$1.base = $2;$n", 15);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_148, "genEnumInfo", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_150, "/home/runner/work/nightlies/nightlies/nim/compiler/jstypes.nim", 62);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_149 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 107),
((NI) 46)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_151, ", \012", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_152, "\"$1\": {kind: 1, offset: $1, typ: $2, name: $3, len: 0, sons: null}", 66);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_153, "var NNI$1 = {kind: 2, offset: 0, typ: null, name: null, len: $2, sons: {$3}};$n", 79);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_154, "$1.node = NNI$2;$n", 18);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_155, "var NNI$1 = $2;$n", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_156, "{kind: 2, len: $1, offset: 0, typ: null, name: null, sons: [$2]}", 64);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_157, "{kind: 1, offset: \"$1\", len: 0, typ: $2, name: $3, sons: null}", 62);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_158, "genObjectFields", 15);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_159 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 42),
((NI) 42)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_160, "genObjectFields; nkOfBranch broken", 34);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_161 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 51),
((NI) 23)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_162, "[$1, $2]", 8);
extern NIM_CONST tyObject_Int128__9a9axPfb75jdWY25AamJewkA Max__int495056_27;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_163, "genObjectFields(nkRecCase)", 26);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_164 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 61),
((NI) 25)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_165, "[setConstr($1), $2]", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_166, "{kind: 3, offset: \"$1\", len: $3, typ: $2, name: $4, sons: [$5]}", 63);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_167 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 69),
((NI) 21)}
;
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_168 = {
0x10, 0x09, 0xe0, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_169, "{kind: 1, offset: \"Field$1\", len: 0, typ: $2, name: \"Field$1\", sons: null}", 74);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_170, "genTypeInfo(", 12);
extern TNimType NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_171 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 155),
((NI) 23)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_172 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_150),
((NI) 156),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_173, "[", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_174, "]", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_175, "{", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_176, "Field$1: $2", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_177, "}", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_178, "m_type: $1", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_179, "$#: ", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_180, "createRecordVarAux", 18);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_181 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1657),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_182, "({$1})", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_183, "[null, 0]", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_184, "[]", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_185, "createVar: ", 11);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_186 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1747),
((NI) 19)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_187 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1750),
((NI) 17)}
;
static NIM_CONST tySet_tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw TM__BxLwT0mhrtgTPodf1v3xjg_188 = {
0xe0, 0x07, 0x77, 0xfc, 0x61, 0x02, 0x00, 0x00,
0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_189, "nimCopy(null, $1, $2)", 21);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_190, " = $3, $2_Idx = $4;$n", 21);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_191, " = [[$3, $4]];$n", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_192, " = [$3, $4];$n", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_193, "Temporary$1", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_194, "var $1 = $2, $3 = $1[0], $3_Idx = $1[1];$n", 42);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_195, " = [$3];$n", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_196, "couldn\'t find the owner proc of the closed over param: ", 55);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_197 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1384),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_198, "$1 = nimCopy(null, $1, $2);$n", 29);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_199, "$1[0][0]", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_200, "$1[0][1]", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_201, "$1[0]", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_202, "$1[1]", 5);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_203 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1424),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_204, "request to generate code for .compileTime proc: ", 48);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_205 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1428),
((NI) 16)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_206 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1444),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_207, "false", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_208, "true", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_209, "null", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_210, "0", 1);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_211 = {
0x10, 0xa9, 0x90, 0x00, 0x00, 0x60, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_212, "makeNimstrLit", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_213, "makeNimstrLit($1)", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_214, "[]", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_215, "-NaN", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_216, "NaN", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_217, "-0.0", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_218, "0.0", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_219, "Infinity", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_220, "-Infinity", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_221, "F.line = $1;$n", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_222, "($1 || $2)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_223, "if ($1) $2 = true; else {", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_224, "$2 = $1;", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_225, "($1 && $2)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_226, "if (!$1) $2 = false; else {", 27);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_227, "& 0xff", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_228, "& 0xffff", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_229, ">>> 0", 5);
extern NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag abstractRange__types_101;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_230, "(($1 $2 $3) $4)", 15);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_231, "+", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_232, "-", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_233, "*", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_234, "/", 1);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_235 = {
0x10, 0xa9, 0x10, 0x00, 0x00, 0x60, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_236, "Math.trunc($1)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_237, "addInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_238, "subInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_239, "mulInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_240, "divInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_241, "modInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_242, "nimMin", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_243, "nimMax", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_244, "negInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_245, "negInt64", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_246, "absInt", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_247, "nimCharToStr", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_248, "nimBoolToStr", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_249, "cstrToNimstr", 12);
N_LIB_PRIVATE NIM_CONST tyArray__k29ck4gbaHsaWs9bvWKy0w5w jsMagics__jsgen_941 = {{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_237),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_238),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_239),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_240),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_241),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_237),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_238),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_242),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_242)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_243),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_243)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_244),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_245),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_246),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_247),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_247)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_248),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_248)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249)}
,
{((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249),
((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249)}
,
{((NimStringDesc*) NIM_NIL),
((NimStringDesc*) NIM_NIL)}
}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_250, "addInt($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_251, "($1 + $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_252, "subInt($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_253, "($1 - $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_254, "mulInt($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_255, "($1 * $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_256, "divInt($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_257, "Math.trunc($1 / $2)", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_258, "modInt($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_259, "Math.trunc($1 % $2)", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_260, "($1 / $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_261, "($1 << $2)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_262, "($1 * Math.pow(2, $2))", 22);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_263, "($1 >> $2)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_264, "Math.floor($1 / Math.pow(2, $2))", 32);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_265, "($1 & $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_266, "($1 | $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_267, "($1 ^ $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_268, "nimMin($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_269, "nimMax($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_270, "($1 % $2)", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_271, "negInt($1)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_272, "negInt64($1)", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_273, "absInt($1)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_274, "Math.abs($1)", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_275, "+($1)", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_276, "~($1)", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_277, "nimCharToStr($1)", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_278, "nimBoolToStr($1)", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_279, "cstrToNimstr(($1) + \"\")", 23);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_280, "cstrToNimstr($1)", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_281, "($1 >>> $2)", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_282, "($# == $# && $# == $#)", 22);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_283, "reprAny", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_284, ", null", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_285, "reprInt", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_286, "reprChar", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_287, "reprBool", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_288, "reprFloat", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_289, "reprStr", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_290, "reprEnum", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_291, "reprSet", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_292, "\'repr\' doesn\'t support \'void\' type", 34);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_293 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1946),
((NI) 14)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_294, "reprPointer", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_295, "reprJSONStringify", 17);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_296 = {
0x10, 0xa9, 0x80, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_297, "genSwap", 7);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_298 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1124),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_299, "var $1 = $2; $2 = $3; $3 = $1;$n", 32);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_300, "var $1 = $2; $2 = $3; $3 = $1;", 30);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_301, "addChar", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_302, "addChar($1, $2);", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_303, "$1[0][$1[1]]", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_304, "($1 = $2, $1)", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_305, "if (null != $1) { if (null == $2) $2 = $3; else $2 += $3; }", 59);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_306, "$1.push.apply($3, $2);", 22);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_307, "$1.push($2);", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_308, "var $1 = nimCopy(null, $2, $3);$n", 33);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_309, "[$1].concat(", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_310, "($1 || []).concat(", 18);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_311, "[$1],", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_312, "$1 || [],", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_313, "[$1])", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_314, "$1 || [])", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_315, "eqStrings", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_316, "eqStrings($1, $2)", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_317, "cmpStrings", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_318, "(cmpStrings($1, $2) <= 0)", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_319, "(cmpStrings($1, $2) < 0)", 24);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_320, "($1 == null)", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_321, "$2", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_322, "($# == null && $# === 0)", 24);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_323, "$1 = $2;$n", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_324, "$1 = [$3]; $2 = 0;$n", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_325, "$1 = [[$2], 0];$n", 17);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_326 = {
0x10, 0xa9, 0x90, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_327, "($1 \? 1 : 0)", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_328, "genOrd", 6);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_329 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1881),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_330, "(($1) == null \? 0 : ($2).length)", 32);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_331, "($1).length", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_332, "(($1) == null \? -1 : ($2).length - 1)", 37);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_333, "($1).length - 1", 15);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_334 = {
0x10, 0xa9, 0xe0, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_335, "chckIndx", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_336, "chckIndx($1, 0, ($2).length - 1)", 32);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_337, "chckIndx($1, $2, ($3).length + ($2) - 1) - ($2)", 47);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_338, "($1) - ($2)", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_339, "$1 = (($5 $2 $3) $4)", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_340, "$1 += $2", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_341, "$1 = addInt($3, $2)", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_342, "$1 -= $2", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_343, "$1 = subInt($3, $2)", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_344, "mnewString", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_345, "($1.length = $2)", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_346, "if ($1.length < $2) { for (var i = $4.length ; i < $5 ; ++i) $4.push($3); }\012 else { $4.length = $5; }", 115);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_347, "SetCard", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_348, "SetCard($1)", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_349, "SetLt", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_350, "SetLt($1, $2)", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_351, "SetLe", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_352, "SetLe($1, $2)", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_353, "SetEq", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_354, "SetEq($1, $2)", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_355, "SetMul", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_356, "SetMul($1, $2)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_357, "SetPlus", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_358, "SetPlus($1, $2)", 15);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_359, "SetMinus", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_360, "SetMinus($1, $2)", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_361, "$1[$2] = true", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_362, "delete $1[$2]", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_363, "($1[$2] != undefined)", 21);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_364, "$1 = new Array($2); for (var i = 0 ; i < $2 ; ++i) { $1[i] = $3; }", 66);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_365 = {
0x10, 0xa9, 0xf0, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_366, "($1.m_type == $2)", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_367, "isObj", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_368, "isObj($1.m_type, $2)", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_369, "genericReset", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_370, "$1 = null, $2 = 0;$n", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_371, "$1 = genericReset($3, $2);$n", 28);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_372 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1624),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_373, "toJSStr", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_374, "rawEcho", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_375, "rawEcho(", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_376, "\'$1\' can only be used in compile-time context", 45);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_377 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2141),
((NI) 14)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_378, "mnewString($1)", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_379, "mnewString(0)", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_380, "($1 = $2, $1[0]), $1[1]", 23);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_381, "($1 = $2, $1)[0]", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_382, "nimParseBiggestFloat", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_383, "($1.slice($2, $3 + 1))", 22);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_384 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1590),
((NI) 19)}
;
static NIM_CONST tySet_tyChar__nmiMWKVIe46vacnhAFrQvw TM__BxLwT0mhrtgTPodf1v3xjg_385 = {
0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_386, "wrong importcpp pattern; expected parameter at position ", 56);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_387, " but got only: ", 15);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_388 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1536),
((NI) 15)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_389, "#", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_390, "@", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_391, "cannot invoke with infix syntax", 31);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_392 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1600),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_393, ".", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_394, "setConstr", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_395, "setConstr(", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_396, "ConstSet", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_397, "var $1 = $2;$n", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_398, "new $1([", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_399, "])", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_400, "Field$#: [$#, $#]", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_401, "Field$#: $#", 11);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_402 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2242),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_403, "$#: [$#, $#]", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_404, "$#: $#", 6);
static NIM_CONST tySet_tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag TM__BxLwT0mhrtgTPodf1v3xjg_405 = {
0x10, 0xa9, 0xe0, 0x00, 0x00, 0xe0, 0x80, 0x00,
0x00}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_406, "{$1}", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_407, "($1 $2)", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_408, "(!!($1))", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_409, "(($1) | 0)", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_410, "genAddr: 3", 10);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_411 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1295),
((NI) 36)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_412, "[0]", 3);
extern TNimType NTItsymkind__cNCW9acsSznmEccl1fgQwkw_;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_413, ",", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_414, "genAddr: 2", 10);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_415 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1322),
((NI) 23)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_416 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1183),
((NI) 17)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_417 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1195),
((NI) 17)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_418 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1199),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_419, "raiseFieldError2", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_420, "reprDiscriminant", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_421, "if ($1[$2.$3]$4undefined) { raiseFieldError2(makeNimstrLit($5), reprDiscriminant($2.$3, $6)); }$n", 97);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_422, "!==", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_423, "===", 3);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_424, "Field", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_425, "genFieldPosition", 16);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_426 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1135),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_427, "genFieldAddr", 12);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_428 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1145),
((NI) 40)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_429 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1149),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_430, "genFieldAccess", 14);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_431 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1173),
((NI) 40)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_432, "expr(nkBracketExpr, ", 20);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_433 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1341),
((NI) 25)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_434, "genAddr for complex nkStmtListExpr", 34);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_435 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1350),
((NI) 23)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_436, "genAddr: ", 9);
extern TNimType NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_437 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1357),
((NI) 19)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_438 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1359),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_439, "genDeref", 8);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_440 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1468),
((NI) 19)}
;
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_441 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1264),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_442, "genArrayAccess", 14);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_443 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1266),
((NI) 32)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_444, "$1.charCodeAt($2)", 17);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_445, "($1 | 0)", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_446, "0xfe", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_447, "0xfffe", 6);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_448, "0xfffffffe", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_449, "($1 - ($2 $3))", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_450, "chckRange", 9);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_451, "chckRange($1, $2, $3)", 21);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_452, "chckRangeF", 10);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_453, "chckRange64", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_454, "convStrToCStr", 13);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_455 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2307),
((NI) 34)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_456, "toJSStr($1)", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_457, "convCStrToStr", 13);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_458 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2319),
((NI) 34)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_459, "genBlock", 8);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_460 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 920),
((NI) 42)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_461, "Label$1: do {$n", 15);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_462, "else {$n", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_463, "if ($1) {$n", 11);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_464 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 715),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_465, "Label$1: while (true) {$n", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_466, "if (!$1) break Label$2;$n", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_467, "for statement not eliminated", 28);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_468 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2607),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_469, "switch (toJSStr($1)) {$n", 24);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_470, "Your case statement contains too many branches, consider using if/else instead!", 79);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_471 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 887),
((NI) 22)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_472, "jsgen.genCaseStmt: 2", 20);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_473 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 898),
((NI) 31)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_474, "default: $n", 11);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_475, "jsgen.genCaseStmt", 17);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_476 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 912),
((NI) 23)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_477, "genReturnStmt", 13);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_478 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2325),
((NI) 36)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_479, "break BeforeRet;$n", 18);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_480, "no loop to break", 16);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_481 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 946),
((NI) 19)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_482, "break Label$1;$n", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_483, "cstring doesn\'t support `[]=` operator", 38);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_484 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1051),
((NI) 14)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_485, "$1 = nimCopy(null, $2, $3);$n", 29);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_486, "nimCopy($1, $2, $3);$n", 22);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_487, "$1 = nimCopy($1, $2, $3);$n", 27);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_488, "var $1 = $4; $2 = $1[0]; $3 = $1[1];$n", 38);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_489, "$# = [$#, $#];$n", 16);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_490 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1089),
((NI) 23)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_491, "$# = [$#, 0];$n", 15);
N_LIB_PRIVATE TNimType NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_495, "genAsgn", 7);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_496 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 1096),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_497, "$1 = $2; $3 = $4;$n", 19);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_498, "var _ = ", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_499, "++excHandler;\012", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_500, "F", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_501, " = framePtr;\012", 13);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_502, "try {$n", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_503, "--excHandler;$n} catch (EXCEPTION) {$n var prevJSError = lastJSError;$n lastJSError = EXCEPTION;$n --excHandler;$n", 114);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_504, "framePtr = $1;$n", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_505, "jsgen.nim(807, 20) `orExpr == nil` ", 35);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_506, "genTryStmt", 10);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_507 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 811),
((NI) 23)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_508, "||", 2);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_509, "lastJSError instanceof $1", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_510, "isObj(lastJSError.m_type, $1)", 29);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_511, "else ", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_512, "if (lastJSError && ($1)) {$n", 28);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_513, "var $1 = lastJSError;$n", 23);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_514, "reraiseException", 16);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_515, "else {\012", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_516, "\011reraiseException();\012", 21);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_517, "lastJSError = prevJSError;$n", 28);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_518, "} finally {\012", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_519, "raiseException", 14);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_520, "raiseException($1, $2);$n", 25);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_521, "reraiseException();\012", 20);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_522, "Closure iterators are not supported by JS backend!", 50);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_523 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2627),
((NI) 17)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_524, "First class iterators not implemented", 37);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_525 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2635),
((NI) 15)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_526, "gen: unknown node type: ", 24);
static NIM_CONST tyTuple__kN8up2W6YKc5YA9avn5mV5w TM__BxLwT0mhrtgTPodf1v3xjg_527 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_6),
((NI) 2639),
((NI) 21)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_528, "$1 = true;$n", 12);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_529, "/* Generated by the Nim Compiler v$1 */\012 var framePtr = null;\012 var excHandler = 0;\012 var lastJSError = null;\012 ", 119);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_530, " ", 1);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_532, "1.6.2", 5);
static NIM_CONST tyArray__nHXaesL0DJZHyVS07ARPRA TM__BxLwT0mhrtgTPodf1v3xjg_531 = {((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_532)}
;
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_533, ".map", 4);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_534, "version", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_535, "sources", 7);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_536, "names", 5);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_537, "mappings", 8);
STRING_LITERAL(TM__BxLwT0mhrtgTPodf1v3xjg_538, "file", 4);
extern tyObject_GcHeap__1TRH1TZMaVZTnLNcIHuNFQ gch__system_5247;
static N_NIMCALL(void, Marker_tyRef__O09bHTFgtn9cJLLJxiNhuKUA)(void* p, NI op) {
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* a;
a = (tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*)p;
nimGCvisit((void*)(*a).Sup.idgen, op);
nimGCvisit((void*)(*a).module, op);
nimGCvisit((void*)(*a).graph, op);
nimGCvisit((void*)(*a).config, op);
nimGCvisit((void*)(*a).sigConflicts.data, op);
}
static N_INLINE(NI, pluspercent___system_696)(NI x, NI y) {
NI result;
result = (NI)0;
result = ((NI) ((NU)((NU64)(((NU) (x))) + (NU64)(((NU) (y))))));
return result;
}
static N_INLINE(void, incRef__system_5338)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c) {
(*c).refcount = pluspercent___system_696((*c).refcount, ((NI) 8));
}
static N_INLINE(NI, minuspercent___system_716)(NI x, NI y) {
NI result;
result = (NI)0;
result = ((NI) ((NU)((NU64)(((NU) (x))) - (NU64)(((NU) (y))))));
return result;
}
static N_INLINE(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*, usrToCell__system_5300)(void* usr) {
tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* result;
NI T1_;
result = (tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*)0;
T1_ = (NI)0;
T1_ = minuspercent___system_716(((NI) (ptrdiff_t) (usr)), ((NI) 16));
result = ((tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*) (T1_));
return result;
}
static N_INLINE(NIM_BOOL, ltpercent___system_1005)(NI x, NI y) {
NIM_BOOL result;
result = (NIM_BOOL)0;
result = ((NU64)(((NU) (x))) < (NU64)(((NU) (y))));
return result;
}
static N_INLINE(void, rtlAddZCT__system_5343)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c) {
addZCT__system_5294((&gch__system_5247.zct), c);
}
static N_INLINE(void, decRef__system_5345)(tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* c) {
(*c).refcount = minuspercent___system_716((*c).refcount, ((NI) 8));
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = ltpercent___system_1005((*c).refcount, ((NI) 8));
if (!T3_) goto LA4_;
rtlAddZCT__system_5343(c);
}
LA4_: ;
}
static N_INLINE(void, asgnRef)(void** dest, void* src) {
{
tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* T5_;
if (!!((src == NIM_NIL))) goto LA3_;
T5_ = (tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*)0;
T5_ = usrToCell__system_5300(src);
incRef__system_5338(T5_);
}
LA3_: ;
{
tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* T10_;
if (!!(((*dest) == NIM_NIL))) goto LA8_;
T10_ = (tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*)0;
T10_ = usrToCell__system_5300((*dest));
decRef__system_5345(T10_);
}
LA8_: ;
(*dest) = src;
}
static N_NIMCALL(void, Marker_tyRef__Q8XTeJJ39cPFyNvJXj9bmcMQ)(void* p, NI op) {
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* a;
NI T1_;
NI T2_;
a = (tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*)p;
nimGCvisit((void*)(*a).typeInfo, op);
nimGCvisit((void*)(*a).constants, op);
nimGCvisit((void*)(*a).code, op);
nimGCvisit((void*)(*a).forwarded, op);
nimGCvisit((void*)(*a).generatedSyms.head, op);
nimGCvisit((void*)(*a).generatedSyms.data, op);
T1_ = (NI)0;
nimGCvisit((void*)(*a).typeInfoGenerated.head, op);
nimGCvisit((void*)(*a).typeInfoGenerated.data, op);
T2_ = (NI)0;
}
static N_INLINE(void, nimGCunrefRC1)(void* p) {
tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g* T1_;
T1_ = (tyObject_Cell__1zcF9cV8XIAtbN8h5HRUB8g*)0;
T1_ = usrToCell__system_5300(p);
decRef__system_5345(T1_);
}
static N_INLINE(void, initIntSet__pureZcollectionsZintsets_238)(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* Result) {
initPackedSet__pureZcollectionsZintsets_16(Result);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*, newGlobals__jsgen_141)(void) {
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* result;
result = NIM_NIL;
result = (tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*) newObj((&NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_), sizeof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag));
(*result).Sup.m_type = (&NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_);
if ((*result).forwarded) { nimGCunrefRC1((*result).forwarded); (*result).forwarded = NIM_NIL; }
initIntSet__pureZcollectionsZintsets_238((&(*result).generatedSyms));
initIntSet__pureZcollectionsZintsets_238((&(*result).typeInfoGenerated));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*, newModule__jsgen_6499)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* module) {
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* result;
result = NIM_NIL;
result = (tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*) newObj((&NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_), sizeof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw));
(*result).Sup.Sup.m_type = (&NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_);
asgnRef((void**) (&(*result).module), module);
initCountTable__cgen_28210(((NI) 32), (&(*result).sigConflicts));
{
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* T5_;
if (!((*g).backend == ((RootObj*) NIM_NIL))) goto LA3_;
T5_ = NIM_NIL;
T5_ = newGlobals__jsgen_141();
asgnRef((void**) (&(*g).backend), &T5_->Sup);
}
LA3_: ;
asgnRef((void**) (&(*result).graph), g);
asgnRef((void**) (&(*result).config), (*g).config);
{
if (!(((*module).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 15))&63U)))!=0)) goto LA8_;
(*(*((tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag**) (&((*g).backend))))).inSystem = NIM_TRUE;
}
LA8_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w*, myOpen__jsgen_6757)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s, tyObject_IdGeneratorcolonObjectType___9a3T65u6nPPLrld0SrEa57Q* idgen) {
tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* result;
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* T1_;
result = NIM_NIL;
T1_ = NIM_NIL;
T1_ = newModule__jsgen_6499(graph, s);
result = &T1_->Sup;
asgnRef((void**) (&(*result).idgen), idgen);
return result;
}
static N_INLINE(NIM_BOOL, skipCodegen__passes_49)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NIM_BOOL result;
result = (NIM_BOOL)0;
result = (((NI) 0) < (*config).errorCounter);
return result;
}
static N_NIMCALL(void, Marker_tySequence__8fytVdU59b5aj319cog2ztLw)(void* p, NI op) {
tySequence__8fytVdU59b5aj319cog2ztLw* a;
NI T1_;
a = (tySequence__8fytVdU59b5aj319cog2ztLw*)p;
T1_ = (NI)0;
}
static N_NIMCALL(void, Marker_tyRef__OFWibP8T8afo89apFNGZiwA)(void* p, NI op) {
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* a;
NI T1_;
NI T2_;
a = (tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*)p;
nimGCvisit((void*)(*a).procDef, op);
nimGCvisit((void*)(*a).prc, op);
nimGCvisit((void*)(*a).globals, op);
nimGCvisit((void*)(*a).locals, op);
nimGCvisit((void*)(*a).body, op);
nimGCvisit((void*)(*a).module, op);
nimGCvisit((void*)(*a).g, op);
nimGCvisit((void*)(*a).generatedParamCopies.head, op);
nimGCvisit((void*)(*a).generatedParamCopies.data, op);
T1_ = (NI)0;
nimGCvisit((void*)(*a).blocks, op);
nimGCvisit((void*)(*a).up, op);
nimGCvisit((void*)(*a).declaredGlobals.head, op);
nimGCvisit((void*)(*a).declaredGlobals.data, op);
T2_ = (NI)0;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*, newProc__jsgen_200)(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* procDef, tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg options) {
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* result;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* T1_;
result = NIM_NIL;
T1_ = NIM_NIL;
T1_ = (tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*) newObj((&NTIpproc__OFWibP8T8afo89apFNGZiwA_), sizeof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q));
if ((*T1_).blocks) { nimGCunrefRC1((*T1_).blocks); (*T1_).blocks = NIM_NIL; }
(*T1_).options = options;
asgnRef((void**) (&(*T1_).module), module);
asgnRef((void**) (&(*T1_).procDef), procDef);
asgnRef((void**) (&(*T1_).g), globals);
(*T1_).extraIndent = ((NI) (!((procDef == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))));
result = T1_;
{
if (!!((procDef == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA4_;
asgnRef((void**) (&(*result).prc), (*(*procDef)._kind_6.sons->data[((NI) 0)])._kind_4.sym);
}
LA4_: ;
return result;
}
static N_INLINE(void, nimSetMem__systemZmemory_7)(void* a, int v, NI size) {
void* T1_;
T1_ = (void*)0;
T1_ = memset(a, v, ((size_t) (size)));
}
static N_INLINE(void, nimZeroMem)(void* p, NI size) {
nimSetMem__systemZmemory_7(p, ((int) 0), size);
}
N_LIB_PRIVATE N_NIMCALL(tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg, initProcOptions__jsgen_237)(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module) {
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg result;
nimZeroMem((void*)(&result), sizeof(tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg));
result = (*(*module).config).options;
{
if (!(*(*((tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag**) (&((*(*module).graph).backend))))).inSystem) goto LA3_;
result &= ~(((NU32)1) << ((((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 17)) & 31));
}
LA3_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*, newInitProc__jsgen_244)(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* module) {
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* result;
tySet_tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg T1_;
result = NIM_NIL;
T1_ = initProcOptions__jsgen_237(module);
result = newProc__jsgen_200(globals, module, ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL), T1_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, indentLine__jsgen_97)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* r) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p_2;
result = NIM_NIL;
result = r;
p_2 = p;
{
while (1) {
{
NI i;
NI colontmp_;
NI T4_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
T4_ = ((*p_2).blocks ? (*p_2).blocks->Sup.len : 0);
colontmp_ = (NI)(T4_ + (*p_2).extraIndent);
i_2 = ((NI) 0);
{
while (1) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
if (!(i_2 < colontmp_)) goto LA6;
i = i_2;
T7_ = NIM_NIL;
T7_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_9));
prepend__ropes_265(&result, T7_);
i_2 += ((NI) 1);
} LA6: ;
}
}
{
NIM_BOOL T10_;
T10_ = (NIM_BOOL)0;
T10_ = ((*p_2).up == ((tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*) NIM_NIL));
if (T10_) goto LA11_;
T10_ = !(((*(*p_2).up).prc == (*(*p_2).prc).owner));
LA11_: ;
if (!T10_) goto LA12_;
goto LA1;
}
LA12_: ;
p_2 = (*p_2).up;
}
} LA1: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5827)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_10), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5832)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_11), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, frameCreate__jsgen_5821)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* procname, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* filename) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T1_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T2_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T3_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T4_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T5_;
result = NIM_NIL;
nimZeroMem((void*)T1_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T1_[0] = procname;
T1_[1] = filename;
T2_ = NIM_NIL;
T2_ = percent___jsgen_5827(T1_, 2);
result = indentLine__jsgen_97(p, T2_);
nimZeroMem((void*)T3_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T4_ = NIM_NIL;
T4_ = percent___jsgen_5832(T3_, 0);
T5_ = NIM_NIL;
T5_ = indentLine__jsgen_97(p, T4_);
add__ropes_159(&result, T5_);
return result;
}
static N_INLINE(void, nimCopyMem)(void* dest, void* source, NI size) {
void* T1_;
T1_ = (void*)0;
T1_ = memcpy(dest, source, ((size_t) (size)));
}
static N_INLINE(void, copyMem__system_1727)(void* dest, void* source, NI size) {
nimCopyMem(dest, source, size);
}
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src) {
{
if (!!((src == ((NimStringDesc*) NIM_NIL)))) goto LA3_;
copyMem__system_1727(((void*) ((&(*dest).data[(*dest).Sup.len]))), ((void*) ((*src).data)), ((NI) ((NI)((*src).Sup.len + ((NI) 1)))));
(*dest).Sup.len += (*src).Sup.len;
}
LA3_: ;
}
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, escapeJSString__jsgen_370)(NimStringDesc* s) {
NimStringDesc* result;
result = NIM_NIL;
result = rawNewString(((NI) ((NI)((s ? s->Sup.len : 0) + (NI)((NI64)((s ? s->Sup.len : 0)) >> (NU64)(((NI) 2)))))));
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_12));
{
NIM_CHAR c;
NI i;
NI L;
c = (NIM_CHAR)0;
i = ((NI) 0);
L = (s ? s->Sup.len : 0);
{
while (1) {
if (!(i < L)) goto LA3;
c = s->data[i];
switch (((NU8)(c))) {
case 10:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_13));
}
break;
case 13:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_14));
}
break;
case 9:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_15));
}
break;
case 8:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_16));
}
break;
case 7:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_17));
}
break;
case 27:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_18));
}
break;
case 11:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_19));
}
break;
case 92:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_20));
}
break;
case 34:
{
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_21));
}
break;
default:
{
result = addChar(result, c);
}
break;
}
i += ((NI) 1);
} LA3: ;
}
}
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_12));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, makeJSString__jsgen_378)(NimStringDesc* s, NIM_BOOL escapeNonAscii) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
{
NimStringDesc* T5_;
if (!escapeNonAscii) goto LA3_;
T5_ = NIM_NIL;
T5_ = nsuEscape(s, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_12), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_12));
result = rope__ropes_109(T5_);
}
goto LA1_;
LA3_: ;
{
NimStringDesc* T7_;
T7_ = NIM_NIL;
T7_ = escapeJSString__jsgen_370(s);
result = rope__ropes_109(T7_);
}
LA1_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_851)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_24), args, argsLen_0);
return result;
}
static N_INLINE(NI, len__ast_3198)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NI result;
NI T1_;
result = (NI)0;
T1_ = ((*n)._kind_6.sons ? (*n)._kind_6.sons->Sup.len : 0);
result = T1_;
return result;
}
static N_INLINE(NI, safeLen__ast_3191)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NI result;
result = (NI)0;
{
if (!((*n).kind >= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 0) && (*n).kind <= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 23))) goto LA3_;
result = ((NI) 0);
}
goto LA1_;
LA3_: ;
{
result = len__ast_3198(n);
}
LA1_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6551)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_26), args, argsLen_0);
return result;
}
static N_INLINE(int, nimCmpMem)(void* a, void* b, NI size) {
int result;
result = (int)0;
result = memcmp(a, b, ((size_t) (size)));
return result;
}
static N_INLINE(NIM_BOOL, equalMem__system_1735)(void* a, void* b, NI size) {
NIM_BOOL result;
int T1_;
result = (NIM_BOOL)0;
T1_ = (int)0;
T1_ = nimCmpMem(a, b, size);
result = (T1_ == ((NI32) 0));
return result;
}
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b) {
NIM_BOOL result;
NI alen;
NI blen;
{ result = (NIM_BOOL)0;
alen = (a ? a->Sup.len : 0);
blen = (b ? b->Sup.len : 0);
{
if (!(alen == blen)) goto LA3_;
{
if (!(alen == ((NI) 0))) goto LA7_;
result = NIM_TRUE;
goto BeforeRet_;
}
LA7_: ;
result = equalMem__system_1735(((void*) ((&a->data[((NI) 0)]))), ((void*) ((&b->data[((NI) 0)]))), ((NI) (alen)));
goto BeforeRet_;
}
LA3_: ;
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, validJsName__jsgen_312)(NimStringDesc* name) {
NIM_BOOL result;
{ result = (NIM_BOOL)0;
result = NIM_TRUE;
switch (hashString(name) & 63) {
case 0:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_60))) goto LA1_;
break;
case 1:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_68))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_88))) goto LA1_;
break;
case 3:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_80))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_84))) goto LA1_;
break;
case 4:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_57))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_70))) goto LA1_;
break;
case 7:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_31))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_56))) goto LA1_;
break;
case 8:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_73))) goto LA1_;
break;
case 10:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_63))) goto LA1_;
break;
case 11:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_59))) goto LA1_;
break;
case 13:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_66))) goto LA1_;
break;
case 15:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_32))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_78))) goto LA1_;
break;
case 17:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_77))) goto LA1_;
break;
case 19:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_53))) goto LA1_;
break;
case 20:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_41))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_65))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_75))) goto LA1_;
break;
case 21:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_39))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_45))) goto LA1_;
break;
case 22:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_90))) goto LA1_;
break;
case 23:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_42))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_67))) goto LA1_;
break;
case 24:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_76))) goto LA1_;
break;
case 25:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_33))) goto LA1_;
break;
case 26:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_38))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_74))) goto LA1_;
break;
case 29:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_37))) goto LA1_;
break;
case 30:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_89))) goto LA1_;
break;
case 34:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_61))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_69))) goto LA1_;
break;
case 36:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_43))) goto LA1_;
break;
case 37:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_71))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_82))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_86))) goto LA1_;
break;
case 38:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_34))) goto LA1_;
break;
case 40:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_81))) goto LA1_;
break;
case 42:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_49))) goto LA1_;
break;
case 44:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_46))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_58))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_64))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_72))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_85))) goto LA1_;
break;
case 45:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_55))) goto LA1_;
break;
case 47:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_40))) goto LA1_;
break;
case 48:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_54))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_87))) goto LA1_;
break;
case 49:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_48))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_52))) goto LA1_;
break;
case 50:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_50))) goto LA1_;
break;
case 54:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_62))) goto LA1_;
break;
case 55:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_29))) goto LA1_;
break;
case 56:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_51))) goto LA1_;
break;
case 57:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_79))) goto LA1_;
break;
case 59:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_36))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_83))) goto LA1_;
break;
case 61:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_30))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_44))) goto LA1_;
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_47))) goto LA1_;
break;
case 62:
if (eqStrings(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_35))) goto LA1_;
break;
}
goto LA2_;
LA1_: ;
{
result = NIM_FALSE;
goto BeforeRet_;
}
goto LA3_;
LA2_: ;
{
}
LA3_: ;
{
if (!(((NU8)(name->data[((NI) 0)])) >= ((NU8)(48)) && ((NU8)(name->data[((NI) 0)])) <= ((NU8)(57)))) goto LA8_;
result = NIM_FALSE;
goto BeforeRet_;
}
LA8_: ;
{
NIM_CHAR chr;
NI i;
NI L;
chr = (NIM_CHAR)0;
i = ((NI) 0);
L = (name ? name->Sup.len : 0);
{
while (1) {
if (!(i < L)) goto LA12;
chr = name->data[i];
{
if (!!((((NU8)(chr)) >= ((NU8)(65)) && ((NU8)(chr)) <= ((NU8)(90)) || ((NU8)(chr)) >= ((NU8)(97)) && ((NU8)(chr)) <= ((NU8)(122)) || ((NU8)(chr)) == ((NU8)(95)) || ((NU8)(chr)) == ((NU8)(36)) || ((NU8)(chr)) >= ((NU8)(48)) && ((NU8)(chr)) <= ((NU8)(57))))) goto LA15_;
result = NIM_FALSE;
goto BeforeRet_;
}
LA15_: ;
i += ((NI) 1);
} LA12: ;
}
}
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, mangleName__jsgen_308)(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = (*s).loc.r;
{
if (!(result == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA3_;
{
NIM_BOOL T7_;
T7_ = (NIM_BOOL)0;
T7_ = ((*s).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 19));
if (!(T7_)) goto LA8_;
T7_ = validJsName__jsgen_312((*(*s).name).s);
LA8_: ;
if (!T7_) goto LA9_;
result = rope__ropes_109((*(*s).name).s);
}
goto LA5_;
LA9_: ;
{
NimStringDesc* T14_;
if (!((*s).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 5))) goto LA12_;
T14_ = NIM_NIL;
T14_ = mangle__ccgutils_112((*(*s).name).s);
result = rope__ropes_109(T14_);
}
goto LA5_;
LA12_: ;
{
NimStringDesc* x;
NI i;
x = rawNewString(((NI) (((*(*s).name).s ? (*(*s).name).s->Sup.len : 0))));
i = ((NI) 0);
{
while (1) {
NIM_CHAR c;
if (!(i < ((*(*s).name).s ? (*(*s).name).s->Sup.len : 0))) goto LA17;
c = (*(*s).name).s->data[i];
switch (((NU8)(c))) {
case 65 ... 90:
case 97 ... 122:
case 95:
case 48 ... 57:
{
x = addChar(x, c);
}
break;
default:
{
NimStringDesc* T20_;
NimStringDesc* T21_;
T20_ = NIM_NIL;
T21_ = NIM_NIL;
T21_ = toHex__pureZstrutils_1792(((NU8)(c)), ((NI) 2));
T20_ = rawNewString((T21_ ? T21_->Sup.len : 0) + 3);
appendString(T20_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_91));
appendString(T20_, T21_);
x = resizeString(x, (T20_ ? T20_->Sup.len : 0) + 0);
appendString(x, T20_);
}
break;
}
i += ((NI) 1);
} LA17: ;
}
result = rope__ropes_109(x);
}
LA5_: ;
{
if (!!(((*s).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 19)))) goto LA24_;
{
NIM_BOOL T28_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T31_;
T28_ = (NIM_BOOL)0;
T28_ = hcrOn__options_569((*m).config);
if (!T28_) goto LA29_;
T31_ = NIM_NIL;
T31_ = idOrSig__sighashes_2057(s, (*(*(*m).module).name).s, (&(*m).sigConflicts));
add__ropes_159(&result, T31_);
}
goto LA26_;
LA29_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T33_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_92));
xX60gensym15_ = s;
T33_ = NIM_NIL;
T33_ = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym15_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym15_).Sup.itemId.item))))));
add__ropes_159(&result, T33_);
}
LA26_: ;
}
LA24_: ;
asgnRef((void**) (&(*s).loc.r), result);
}
LA3_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4072)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_93), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4081)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_94), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA, mapType__jsgen_277)(tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA result;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
result = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
t = skipTypes__ast_3735(typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
switch ((*t).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T4_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T5_;
T4_ = NIM_NIL;
T4_ = lastSon__ast_3743(t);
T5_ = NIM_NIL;
T5_ = skipTypes__ast_3735(T4_, TM__BxLwT0mhrtgTPodf1v3xjg_97);
if (!((*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17) || (*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16) || (*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18) || (*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27) || (*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19) || (*T5_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48))) goto LA6_;
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8);
}
goto LA2_;
LA6_: ;
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
}
LA2_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 20):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 13):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 15):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 50):
{
result = mapType__jsgen_277((*t).sons->data[((NI) 0)]);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 35):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 5);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 3);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 36) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 39):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 6);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 4);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 49):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 5):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 1);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 12):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 10):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 9):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 0):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 61):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 30):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 3):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 6):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 7):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 8):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 51):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 54):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 56):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 57):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 58):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 59):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 63):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 11):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 55):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 4):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 52):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 53):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 46):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45):
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T20_;
T20_ = NIM_NIL;
T20_ = lastSon__ast_3743(typ);
result = mapType__jsgen_277(T20_);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 60):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T26_;
if (!!(((*t).n == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA24_;
T26_ = NIM_NIL;
T26_ = lastSon__ast_3743(t);
result = mapType__jsgen_277(T26_);
}
goto LA22_;
LA24_: ;
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
LA22_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 25):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 2);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29):
{
result = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 7);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 62):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 64):
{
{
if (!NIM_TRUE) goto LA33_;
failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_98));
}
LA33_: ;
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA, mapType__jsgen_304)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA result;
result = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
result = mapType__jsgen_277(typ);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4124)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_99), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4129)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_100), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1262)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) NIM_NIL), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3786)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_103), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, putToSeq__jsgen_3782)(NimStringDesc* s, NIM_BOOL indirect) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = rope__ropes_109(s);
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T5_;
if (!indirect) goto LA3_;
nimZeroMem((void*)T5_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T5_[0] = result;
result = percent___jsgen_3786(T5_, 1);
}
LA3_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, arrayTypeForElemType__jsgen_3959)(tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
NimStringDesc* result;
result = NIM_NIL;
switch ((*typ).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 34):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_108));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 33):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_109));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 32):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_110));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 43):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_111));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 42):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_112));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 41):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_113));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 37):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_114));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 38):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 36):
{
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_115));
}
break;
default:
{
result = ((NimStringDesc*) NIM_NIL);
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3974)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_116), args, argsLen_0);
return result;
}
static N_INLINE(void, addInt__stdZprivateZdigitsutils_189)(NimStringDesc** result, NI x) {
addInt__stdZprivateZdigitsutils_167(result, ((NI64) (x)));
}
static N_INLINE(NimStringDesc*, toFileLineCol__msgs_615)(tyTuple__kN8up2W6YKc5YA9avn5mV5w info) {
NimStringDesc* result;
result = NIM_NIL;
result = resizeString(result, (info.Field0 ? info.Field0->Sup.len : 0) + 0);
appendString(result, info.Field0);
{
if (!(((NI) 0) < info.Field1)) goto LA3_;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_117));
addInt__stdZprivateZdigitsutils_189((&result), info.Field1);
{
if (!(((NI) 0) < (NI)(info.Field2 + ((NI) 1)))) goto LA7_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
addInt__stdZprivateZdigitsutils_189((&result), (NI)(info.Field2 + ((NI) 1)));
}
LA7_: ;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
}
LA3_: ;
return result;
}
static N_INLINE(NIM_BOOL, isCompileTimeOnly__types_3528)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t) {
NIM_BOOL result;
result = (NIM_BOOL)0;
result = ((*t).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 8) || (*t).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 60));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, generateHeader__jsgen_2418)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198((*typ).n);
i_2 = ((NI) 1);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* param;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name;
param = (*(*(*typ).n)._kind_6.sons->data[i])._kind_4.sym;
{
NIM_BOOL T7_;
T7_ = (NIM_BOOL)0;
T7_ = isCompileTimeOnly__types_3528((*param).typ);
if (!T7_) goto LA8_;
goto LA4;
}
LA8_: ;
{
if (!!((result == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA12_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA12_: ;
name = mangleName__jsgen_308((*p).module, param);
add__ropes_159(&result, name);
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T16_;
T16_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T16_ = mapType__jsgen_277((*param).typ);
if (!(T16_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA17_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
add__ropes_159(&result, name);
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_121));
}
LA17_: ;
} LA4: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5921)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_122), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5926)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_123), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5954)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_124), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5964)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_125), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5969)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_126), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1813)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_127), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, lineDir__jsgen_1808)(tyObject_ConfigRefcolonObjectType___LaK09ayL9alwKUad7rts0rTw* config, tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info, NI line) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T1_;
NimStringDesc* T2_;
result = NIM_NIL;
nimZeroMem((void*)T1_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T2_ = NIM_NIL;
T2_ = toFullPath__msgs_538(config, info.fileIndex);
T1_[0] = rope__ropes_109(T2_);
T1_[1] = rope__ropes_115(((NI64) (line)));
result = percent___jsgen_1813(T1_, 2);
return result;
}
static N_INLINE(NI, toLinenumber__msgs_609)(tyObject_TLineInfo__WGx4rAexNXnczy1Avn646Q info) {
NI result;
result = (NI)0;
result = ((NI) (info.line));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, optionalLine__jsgen_5862)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* p) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
{ result = NIM_NIL;
{
if (!(p == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA3_;
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
goto BeforeRet_;
}
goto LA1_;
LA3_: ;
{
result = amp___ropes_140(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_129));
goto BeforeRet_;
}
LA1_: ;
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, hasFrameInfo__jsgen_1789)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p) {
NIM_BOOL result;
NIM_BOOL T1_;
NIM_BOOL T3_;
result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = ((655360 & (*p).options) == 655360);
if (!(T1_)) goto LA2_;
T3_ = (NIM_BOOL)0;
T3_ = ((*p).prc == ((tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*) NIM_NIL));
if (T3_) goto LA4_;
T3_ = !((((*(*p).prc).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 11))&63U)))!=0));
LA4_: ;
T1_ = T3_;
LA2_: ;
result = T1_;
return result;
}
static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c) {
(*dest).data[(*dest).Sup.len] = c;
(*dest).data[(NI)((*dest).Sup.len + ((NI) 1))] = 0;
(*dest).Sup.len += ((NI) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5844)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_130), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2287)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_131), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5857)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_132), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, frameDestroy__jsgen_5837)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T1_;
result = NIM_NIL;
T1_ = NIM_NIL;
T1_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_133));
result = indentLine__jsgen_97(p, T1_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genProcBody__jsgen_5840)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
{
NIM_BOOL T3_;
NimStringDesc* T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
NimStringDesc* T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
T3_ = (NIM_BOOL)0;
T3_ = hasFrameInfo__jsgen_1789(p);
if (!T3_) goto LA4_;
T6_ = NIM_NIL;
T6_ = rawNewString(((*(*(*prc).owner).name).s ? (*(*(*prc).owner).name).s->Sup.len : 0) + ((*(*prc).name).s ? (*(*prc).name).s->Sup.len : 0) + 1);
appendString(T6_, (*(*(*prc).owner).name).s);
appendChar(T6_, 46);
appendString(T6_, (*(*prc).name).s);
T7_ = NIM_NIL;
T7_ = makeJSString__jsgen_378(T6_, NIM_TRUE);
T8_ = NIM_NIL;
T8_ = toFilenameOption__msgs_590((*(*p).module).config, (*prc).info.fileIndex, ((tyEnum_FilenameOption__eL86bAtPxXWHj24F5gOMFQ) 5));
T9_ = NIM_NIL;
T9_ = makeJSString__jsgen_378(T8_, NIM_TRUE);
result = frameCreate__jsgen_5821(p, T7_, T9_);
}
goto LA1_;
LA4_: ;
{
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
}
LA1_: ;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T18_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
if (!(*p).beforeRetNeeded) goto LA13_;
nimZeroMem((void*)T15_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T16_ = NIM_NIL;
T16_ = percent___jsgen_5844(T15_, 0);
T17_ = NIM_NIL;
T17_ = indentLine__jsgen_97(p, T16_);
add__ropes_159(&result, T17_);
add__ropes_159(&result, (*p).body);
nimZeroMem((void*)T18_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T19_ = NIM_NIL;
T19_ = percent___jsgen_2287(T18_, 0);
T20_ = NIM_NIL;
T20_ = indentLine__jsgen_97(p, T19_);
add__ropes_159(&result, T20_);
}
goto LA11_;
LA13_: ;
{
add__ropes_159(&result, (*p).body);
}
LA11_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T26_;
if (!((*(*prc).typ).callConv == ((tyEnum_TCallingConvention__yjAJ8w0h1PBaSwSGJ3P7IA) 4))) goto LA24_;
nimZeroMem((void*)T26_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T26_[0] = result;
result = percent___jsgen_5857(T26_, 1);
}
LA24_: ;
{
NIM_BOOL T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T32_;
T29_ = (NIM_BOOL)0;
T29_ = hasFrameInfo__jsgen_1789(p);
if (!T29_) goto LA30_;
T32_ = NIM_NIL;
T32_ = frameDestroy__jsgen_5837(p);
add__ropes_159(&result, T32_);
}
LA30_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6000)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_135), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6005)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_136), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genProc__jsgen_773)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* oldProc, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* resultSym;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* returnStmt;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* resultAsgn;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* header;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* transformedBody;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* def;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T69_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T70_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T71_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T72_;
result = NIM_NIL;
resultSym = NIM_NIL;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
p = newProc__jsgen_200((*oldProc).g, (*oldProc).module, (*prc).ast, (*prc).options);
asgnRef((void**) (&(*p).up), oldProc);
returnStmt = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
resultAsgn = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
name = mangleName__jsgen_308((*p).module, prc);
header = generateHeader__jsgen_2418(p, (*prc).typ);
{
NIM_BOOL T3_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* mname;
T3_ = (NIM_BOOL)0;
T3_ = !(((*(*prc).typ).sons->data[((NI) 0)] == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)));
if (!(T3_)) goto LA4_;
T3_ = !((((*prc).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 11))&63U)))!=0));
LA4_: ;
if (!T3_) goto LA5_;
resultSym = (*(*(*prc).ast)._kind_6.sons->data[((NI) 7)])._kind_4.sym;
mname = mangleName__jsgen_308((*p).module, resultSym);
{
NIM_BOOL T9_;
NIM_BOOL T10_;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym1132_;
NIM_BOOL T11_;
NIM_BOOL T12_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T17_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T23_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T24_;
T9_ = (NIM_BOOL)0;
T10_ = (NIM_BOOL)0;
vX60gensym1132_ = resultSym;
T11_ = (NIM_BOOL)0;
T12_ = (NIM_BOOL)0;
T12_ = !(((131080 & (*vX60gensym1132_).flags) == 0));
if (!(T12_)) goto LA13_;
T12_ = ((192 & (*vX60gensym1132_).flags) == 0);
LA13_: ;
T11_ = T12_;
if (!(T11_)) goto LA14_;
T11_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym1132_).kind)&31U)))!=0));
LA14_: ;
T10_ = !(T11_);
if (!(T10_)) goto LA15_;
T10_ = ((*(*resultSym).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23) || (*(*resultSym).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21) || (*(*resultSym).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47) || (*(*resultSym).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22) || (*(*resultSym).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45));
LA15_: ;
T9_ = T10_;
if (!(T9_)) goto LA16_;
T17_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T17_ = mapType__jsgen_304(p, (*resultSym).typ);
T9_ = (T17_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA16_: ;
if (!T9_) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T20_[0] = mname;
T21_ = NIM_NIL;
T21_ = percent___jsgen_5921(T20_, 1);
resultAsgn = indentLine__jsgen_97(p, T21_);
nimZeroMem((void*)T22_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T22_[0] = mname;
T23_ = NIM_NIL;
T23_ = percent___jsgen_5926(T22_, 1);
T24_ = NIM_NIL;
T24_ = indentLine__jsgen_97(p, T23_);
add__ropes_159(&resultAsgn, T24_);
}
goto LA7_;
LA18_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* resVar;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym1136_;
NIM_BOOL T26_;
NIM_BOOL T27_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T30_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T31_;
vX60gensym1136_ = resultSym;
T26_ = (NIM_BOOL)0;
T27_ = (NIM_BOOL)0;
T27_ = !(((131080 & (*vX60gensym1136_).flags) == 0));
if (!(T27_)) goto LA28_;
T27_ = ((192 & (*vX60gensym1136_).flags) == 0);
LA28_: ;
T26_ = T27_;
if (!(T26_)) goto LA29_;
T26_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym1136_).kind)&31U)))!=0));
LA29_: ;
resVar = createVar__jsgen_3791(p, (*resultSym).typ, T26_);
nimZeroMem((void*)T30_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T30_[0] = mname;
T30_[1] = resVar;
T31_ = NIM_NIL;
T31_ = percent___jsgen_5954(T30_, 2);
resultAsgn = indentLine__jsgen_97(p, T31_);
}
LA7_: ;
gen__jsgen_766(p, (*(*prc).ast)._kind_6.sons->data[((NI) 7)], (&a));
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T34_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T37_;
T34_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T34_ = mapType__jsgen_304(p, (*resultSym).typ);
if (!(T34_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA35_;
nimZeroMem((void*)T37_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T37_[0] = a.address;
T37_[1] = a.res;
returnStmt = percent___jsgen_5964(T37_, 2);
}
goto LA32_;
LA35_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T39_;
nimZeroMem((void*)T39_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T39_[0] = a.res;
returnStmt = percent___jsgen_5969(T39_, 1);
}
LA32_: ;
}
LA5_: ;
transformedBody = transformBody__transf_16((*(*p).module).graph, (*(*p).module).Sup.idgen, prc, NIM_FALSE);
{
if (!(((*prc).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 42))&63U)))!=0)) goto LA42_;
transformedBody = injectDestructorCalls__injectdestructors_10100((*(*p).module).graph, (*(*p).module).Sup.idgen, prc, transformedBody);
}
LA42_: ;
(*p).extraIndent += ((NI) 1);
genStmt__jsgen_770(p, transformedBody);
(*p).extraIndent -= ((NI) 1);
{
NI T48_;
if (!(((*(*(*p).module).config).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 12))&31U)))!=0)) goto LA46_;
T48_ = (NI)0;
T48_ = toLinenumber__msgs_609((*prc).info);
result = lineDir__jsgen_1808((*(*p).module).config, (*prc).info, T48_);
}
LA46_: ;
def = NIM_NIL;
{
NimStringDesc* T53_;
tyArray__wm6rkCVggH4IozhLUEP19bg T54_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T55_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T56_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T57_;
if (!!(((*prc).constraint == 0))) goto LA51_;
T53_ = NIM_NIL;
T53_ = rawNewString(((*(*prc).constraint)._kind_3.strVal ? (*(*prc).constraint)._kind_3.strVal->Sup.len : 0) + 14);
appendString(T53_, (*(*prc).constraint)._kind_3.strVal);
appendString(T53_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_128));
nimZeroMem((void*)T54_, sizeof(tyArray__wm6rkCVggH4IozhLUEP19bg));
nimZeroMem((void*)T55_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T54_[0] = percent___jsgen_1262(T55_, 0);
T54_[1] = name;
T54_[2] = header;
T54_[3] = optionalLine__jsgen_5862((*p).globals);
T54_[4] = optionalLine__jsgen_5862((*p).locals);
T54_[5] = optionalLine__jsgen_5862(resultAsgn);
T56_ = NIM_NIL;
T56_ = genProcBody__jsgen_5840(p, prc);
T54_[6] = optionalLine__jsgen_5862(T56_);
T57_ = NIM_NIL;
T57_ = indentLine__jsgen_97(p, returnStmt);
T54_[7] = optionalLine__jsgen_5862(T57_);
def = runtimeFormat__ropes_271(T53_, T54_, 8);
}
goto LA49_;
LA51_: ;
{
tyArray__YcHYlgE5mhtkt9a3rnoucVg T66_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T67_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T68_;
{
NIM_BOOL T61_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* thunkName;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T64_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T65_;
T61_ = (NIM_BOOL)0;
T61_ = hcrOn__options_569((*(*p).module).config);
if (!T61_) goto LA62_;
thunkName = name;
name = amp___ropes_140(name, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_134));
nimZeroMem((void*)T64_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T64_[0] = thunkName;
T64_[1] = name;
T65_ = NIM_NIL;
T65_ = percent___jsgen_6000(T64_, 2);
add__ropes_159(&result, T65_);
}
LA62_: ;
nimZeroMem((void*)T66_, sizeof(tyArray__YcHYlgE5mhtkt9a3rnoucVg));
T66_[0] = name;
T66_[1] = header;
T66_[2] = optionalLine__jsgen_5862((*p).globals);
T66_[3] = optionalLine__jsgen_5862((*p).locals);
T66_[4] = optionalLine__jsgen_5862(resultAsgn);
T67_ = NIM_NIL;
T67_ = genProcBody__jsgen_5840(p, prc);
T66_[5] = optionalLine__jsgen_5862(T67_);
T68_ = NIM_NIL;
T68_ = indentLine__jsgen_97(p, returnStmt);
T66_[6] = optionalLine__jsgen_5862(T68_);
def = percent___jsgen_6005(T66_, 7);
}
LA49_: ;
(*p).extraIndent -= ((NI) 1);
T69_ = NIM_NIL;
T69_ = indentLine__jsgen_97(p, def);
add__ropes_159(&result, T69_);
nimZeroMem((void*)T70_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T71_ = NIM_NIL;
T71_ = percent___cgen_7505(T70_, 0);
T72_ = NIM_NIL;
T72_ = indentLine__jsgen_97(p, T71_);
add__ropes_159(&result, T72_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, useMagic__jsgen_779)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, NimStringDesc* name) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s;
{ {
if (!((name ? name->Sup.len : 0) == ((NI) 0))) goto LA3_;
goto BeforeRet_;
}
LA3_: ;
s = getCompilerProc__magicsys_145((*(*p).module).graph, name);
{
if (!!((s == ((tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*) NIM_NIL)))) goto LA7_;
{
NimStringDesc* argX60gensym96_;
if (!!(((94208 &((NU32)1<<((NU)((*s).kind)&31U)))!=0))) goto LA11_;
argX60gensym96_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_120);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym96_, TM__BxLwT0mhrtgTPodf1v3xjg_120);
}
LA11_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym98_;
NIM_BOOL T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* code;
xX60gensym98_ = s;
T15_ = (NIM_BOOL)0;
T15_ = containsOrIncl__astalgo_402((&(*(*p).g).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym98_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym98_).Sup.itemId.item))));
if (!!(T15_)) goto LA16_;
code = genProc__jsgen_773(p, s);
add__ropes_159(&(*(*p).g).constants, code);
}
LA16_: ;
}
goto LA5_;
LA7_: ;
{
{
NimStringDesc* T23_;
if (!!(((*p).prc == ((tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*) NIM_NIL)))) goto LA21_;
T23_ = NIM_NIL;
T23_ = rawNewString((name ? name->Sup.len : 0) + 21);
appendString(T23_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_137));
appendString(T23_, name);
liMessage__msgs_1118((*(*p).module).config, (*(*p).prc).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), T23_, ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 2), TM__BxLwT0mhrtgTPodf1v3xjg_138, NIM_FALSE);
}
goto LA19_;
LA21_: ;
{
NimStringDesc* T25_;
T25_ = NIM_NIL;
T25_ = rawNewString((name ? name->Sup.len : 0) + 21);
appendString(T25_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_137));
appendString(T25_, name);
liMessage__msgs_1118((*(*p).module).config, unknownLineInfo__lineinfos_280, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), T25_, ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 1), TM__BxLwT0mhrtgTPodf1v3xjg_139, NIM_FALSE);
}
LA19_: ;
}
LA5_: ;
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3979)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_142), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_689)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_144), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_719)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_145), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_505)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_146), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_543)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_147), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_631)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_152), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_645)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_153), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_528)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_154), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genEnumInfo__jsgen_606)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* n;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T19_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym73_;
NI T20_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T21_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T22_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym74_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T23_;
s = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198((*typ).n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* field;
NimStringDesc* extName;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!!(((*(*(*typ).n)._kind_6.sons->data[i]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3)))) goto LA6_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*typ).n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_148), TM__BxLwT0mhrtgTPodf1v3xjg_149);
}
LA6_: ;
field = (*(*(*typ).n)._kind_6.sons->data[i])._kind_4.sym;
{
if (!(((NI) 0) < i)) goto LA10_;
add__ropes_162(&s, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_151));
}
LA10_: ;
{
if (!((*field).ast == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL))) goto LA14_;
extName = (*(*field).name).s;
}
goto LA12_;
LA14_: ;
{
extName = (*(*field).ast)._kind_3.strVal;
}
LA12_: ;
nimZeroMem((void*)T17_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T17_[0] = rope__ropes_115(((NI64) ((*field).position)));
T17_[1] = name;
T17_[2] = makeJSString__jsgen_378(extName, NIM_TRUE);
T18_ = NIM_NIL;
T18_ = percent___jsgen_631(T17_, 3);
add__ropes_159(&s, T18_);
i_2 += ((NI) 1);
} LA3: ;
}
}
nimZeroMem((void*)T19_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
xX60gensym73_ = typ;
T19_[0] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym73_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym73_).Sup.itemId.item))))));
T20_ = (NI)0;
T20_ = len__ast_3198((*typ).n);
T19_[1] = rope__ropes_115(((NI64) (T20_)));
T19_[2] = s;
n = percent___jsgen_645(T19_, 3);
nimZeroMem((void*)T21_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T21_[0] = name;
T21_[1] = rope__ropes_115(((NI64) ((*typ).kind)));
s = percent___jsgen_505(T21_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s);
add__ropes_159(&(*(*p).g).typeInfo, n);
nimZeroMem((void*)T22_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T22_[0] = name;
xX60gensym74_ = typ;
T22_[1] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym74_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym74_).Sup.itemId.item))))));
T23_ = NIM_NIL;
T23_ = percent___jsgen_528(T22_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T23_);
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T28_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T29_;
if (!!(((*typ).sons->data[((NI) 0)] == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)))) goto LA26_;
nimZeroMem((void*)T28_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T28_[0] = name;
T28_[1] = genTypeInfo__jsgen_385(p, (*typ).sons->data[((NI) 0)]);
T29_ = NIM_NIL;
T29_ = percent___jsgen_543(T28_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T29_);
}
LA26_: ;
}
static N_INLINE(NIM_BOOL, objHasTypeField__jsgen_485)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t) {
NIM_BOOL result;
NIM_BOOL T1_;
result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = (((*t).flags &((NU64)1<<((NU)(((tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw) 3))&63U)))!=0);
if (T1_) goto LA2_;
T1_ = !(((*t).sons->data[((NI) 0)] == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)));
LA2_: ;
result = T1_;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_517)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_155), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_413)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_156), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_418)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_157), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_462)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_162), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rope__jsgen_382)(tyObject_Int128__9a9axPfb75jdWY25AamJewkA arg) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
NimStringDesc* T1_;
result = NIM_NIL;
T1_ = NIM_NIL;
T1_ = dollar___int495056_53(arg);
result = rope__ropes_109(T1_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_475)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_165), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_480)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_166), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genObjectFields__jsgen_388)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* u;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* field;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b;
result = NIM_NIL;
s = NIM_NIL;
u = NIM_NIL;
field = NIM_NIL;
b = NIM_NIL;
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
switch ((*n).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 138):
{
{
NI T4_;
T4_ = (NI)0;
T4_ = len__ast_3198(n);
if (!(T4_ == ((NI) 1))) goto LA5_;
result = genObjectFields__jsgen_388(p, typ, (*n)._kind_6.sons->data[((NI) 0)]);
}
goto LA2_;
LA5_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T16_;
NI T17_;
s = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
if (!(i_2 < colontmp_)) goto LA10;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA13_;
add__ropes_162(&s, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_151));
}
LA13_: ;
T15_ = NIM_NIL;
T15_ = genObjectFields__jsgen_388(p, typ, (*n)._kind_6.sons->data[i]);
add__ropes_159(&s, T15_);
i_2 += ((NI) 1);
} LA10: ;
}
}
nimZeroMem((void*)T16_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_ = (NI)0;
T17_ = len__ast_3198(n);
T16_[0] = rope__ropes_115(((NI64) (T17_)));
T16_[1] = s;
result = percent___jsgen_413(T16_, 2);
}
LA2_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T19_;
field = (*n)._kind_4.sym;
s = genTypeInfo__jsgen_385(p, (*field).typ);
nimZeroMem((void*)T19_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T19_[0] = mangleName__jsgen_308((*p).module, field);
T19_[1] = s;
T19_[2] = makeJSString__jsgen_378((*(*field).name).s, NIM_TRUE);
result = percent___jsgen_418(T19_, 3);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 139):
{
tyArray__duFhZXIIlrbrM62cWjNekg T63_;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T64_;
{
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3)))) goto LA23_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_158), TM__BxLwT0mhrtgTPodf1v3xjg_159);
}
LA23_: ;
field = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
s = genTypeInfo__jsgen_385(p, (*field).typ);
{
NI i_3;
NI colontmp__2;
NI i_4;
i_3 = (NI)0;
colontmp__2 = (NI)0;
colontmp__2 = len__ast_3198(n);
i_4 = ((NI) 1);
{
while (1) {
tyArray__mrugoXXRZUEeG9bEXo9auBKw T60_;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T61_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T62_;
if (!(i_4 < colontmp__2)) goto LA27;
i_3 = i_4;
b = (*n)._kind_6.sons->data[i_3];
u = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
switch ((*b).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 85):
{
{
NI T31_;
T31_ = (NI)0;
T31_ = len__ast_3198(b);
if (!(T31_ < ((NI) 2))) goto LA32_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*b).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_160), TM__BxLwT0mhrtgTPodf1v3xjg_161);
}
LA32_: ;
{
NI j;
NI colontmp__3;
NI T35_;
NI i_5;
j = (NI)0;
colontmp__3 = (NI)0;
T35_ = (NI)0;
T35_ = len__ast_3198(b);
colontmp__3 = (NI)(T35_ - ((NI) 1));
i_5 = ((NI) 0);
{
while (1) {
if (!(i_5 < colontmp__3)) goto LA37;
j = i_5;
{
if (!!((u == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA40_;
add__ropes_162(&u, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA40_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T46_;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T47_;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T48_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T49_;
if (!((*(*b)._kind_6.sons->data[j]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 44))) goto LA44_;
nimZeroMem((void*)T46_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T47_ = getOrdValue__types_161((*(*b)._kind_6.sons->data[j])._kind_6.sons->data[((NI) 0)], Max__int495056_27);
T46_[0] = rope__jsgen_382(T47_);
T48_ = getOrdValue__types_161((*(*b)._kind_6.sons->data[j])._kind_6.sons->data[((NI) 1)], Max__int495056_27);
T46_[1] = rope__jsgen_382(T48_);
T49_ = NIM_NIL;
T49_ = percent___jsgen_462(T46_, 2);
add__ropes_159(&u, T49_);
}
goto LA42_;
LA44_: ;
{
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T51_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T52_;
T51_ = getOrdValue__types_161((*b)._kind_6.sons->data[j], Max__int495056_27);
T52_ = NIM_NIL;
T52_ = rope__jsgen_382(T51_);
add__ropes_159(&u, T52_);
}
LA42_: ;
i_5 += ((NI) 1);
} LA37: ;
}
}
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 88):
{
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T54_;
T54_ = lengthOrd__types_1661((*(*p).module).config, (*field).typ);
u = rope__jsgen_382(T54_);
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_163), TM__BxLwT0mhrtgTPodf1v3xjg_164);
}
break;
}
{
if (!!((result == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA58_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_151));
}
LA58_: ;
nimZeroMem((void*)T60_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T60_[0] = u;
T61_ = NIM_NIL;
T61_ = lastSon__ast_4832(b);
T60_[1] = genObjectFields__jsgen_388(p, typ, T61_);
T62_ = NIM_NIL;
T62_ = percent___jsgen_475(T60_, 2);
add__ropes_159(&result, T62_);
i_4 += ((NI) 1);
} LA27: ;
}
}
nimZeroMem((void*)T63_, sizeof(tyArray__duFhZXIIlrbrM62cWjNekg));
T63_[0] = mangleName__jsgen_308((*p).module, field);
T63_[1] = s;
T64_ = lengthOrd__types_1661((*(*p).module).config, (*field).typ);
T63_[2] = rope__jsgen_382(T64_);
T63_[3] = makeJSString__jsgen_378((*(*field).name).s, NIM_TRUE);
T63_[4] = result;
result = percent___jsgen_480(T63_, 5);
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_158), TM__BxLwT0mhrtgTPodf1v3xjg_167);
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genObjectInfo__jsgen_497)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name) {
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag kind;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T7_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T8_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym50_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T10_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym52_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = objHasTypeField__jsgen_485(typ);
if (!T3_) goto LA4_;
kind = ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17);
}
goto LA1_;
LA4_: ;
{
kind = ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18);
}
LA1_: ;
nimZeroMem((void*)T7_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T7_[0] = name;
T7_[1] = rope__ropes_115(((NI64) (kind)));
s = percent___jsgen_505(T7_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s);
nimZeroMem((void*)T8_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
xX60gensym50_ = typ;
T8_[0] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym50_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym50_).Sup.itemId.item))))));
T8_[1] = genObjectFields__jsgen_388(p, typ, (*typ).n);
T9_ = NIM_NIL;
T9_ = percent___jsgen_517(T8_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T9_);
nimZeroMem((void*)T10_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T10_[0] = name;
xX60gensym52_ = typ;
T10_[1] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym52_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym52_).Sup.itemId.item))))));
T11_ = NIM_NIL;
T11_ = percent___jsgen_528(T10_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T11_);
{
NIM_BOOL T14_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T18_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
T14_ = (NIM_BOOL)0;
T14_ = ((*typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17));
if (!(T14_)) goto LA15_;
T14_ = !(((*typ).sons->data[((NI) 0)] == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)));
LA15_: ;
if (!T14_) goto LA16_;
nimZeroMem((void*)T18_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T18_[0] = name;
T19_ = NIM_NIL;
T19_ = skipTypes__ast_3735((*typ).sons->data[((NI) 0)], TM__BxLwT0mhrtgTPodf1v3xjg_168);
T18_[1] = genTypeInfo__jsgen_385(p, T19_);
T20_ = NIM_NIL;
T20_ = percent___jsgen_543(T18_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T20_);
}
LA16_: ;
}
static N_INLINE(NI, len__ast_4002)(tyObject_TType__facALICuu8zUj0hjvbTLFg* n) {
NI result;
NI T1_;
result = (NI)0;
T1_ = ((*n).sons ? (*n).sons->Sup.len : 0);
result = T1_;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_562)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_169), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genTupleFields__jsgen_548)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T10_;
NI T11_;
result = NIM_NIL;
s = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_4002(typ);
i_2 = ((NI) 0);
{
while (1) {
tyArray__mrugoXXRZUEeG9bEXo9auBKw T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA6_;
add__ropes_162(&s, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_151));
}
LA6_: ;
nimZeroMem((void*)T8_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T8_[0] = rope__ropes_115(((NI64) (i)));
T8_[1] = genTypeInfo__jsgen_385(p, (*typ).sons->data[i]);
T9_ = NIM_NIL;
T9_ = percent___jsgen_562(T8_, 2);
add__ropes_159(&s, T9_);
i_2 += ((NI) 1);
} LA3: ;
}
}
nimZeroMem((void*)T10_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T11_ = (NI)0;
T11_ = len__ast_4002(typ);
T10_[0] = rope__ropes_115(((NI64) (T11_)));
T10_[1] = s;
result = percent___jsgen_413(T10_, 2);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genTupleInfo__jsgen_574)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* name) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T1_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T2_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym61_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T3_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T4_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym63_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T5_;
nimZeroMem((void*)T1_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T1_[0] = name;
T1_[1] = rope__ropes_115(((NI64) ((*typ).kind)));
s = percent___jsgen_505(T1_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s);
nimZeroMem((void*)T2_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
xX60gensym61_ = typ;
T2_[0] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym61_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym61_).Sup.itemId.item))))));
T2_[1] = genTupleFields__jsgen_548(p, typ);
T3_ = NIM_NIL;
T3_ = percent___jsgen_517(T2_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T3_);
nimZeroMem((void*)T4_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T4_[0] = name;
xX60gensym63_ = typ;
T4_[1] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym63_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym63_).Sup.itemId.item))))));
T5_ = NIM_NIL;
T5_ = percent___jsgen_528(T4_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T5_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genTypeInfo__jsgen_385)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyArray__JiWwrsTRC6xqNlGcBthSVA T1_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym80_;
{ result = NIM_NIL;
t = skipTypes__ast_3735(typ, TM__BxLwT0mhrtgTPodf1v3xjg_143);
nimZeroMem((void*)T1_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
xX60gensym80_ = t;
T1_[0] = rope__ropes_115(((NI64) ((NI)((NI)((NU64)(((NI) ((*xX60gensym80_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym80_).Sup.itemId.item))))));
result = percent___jsgen_689(T1_, 1);
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* xX60gensym81_;
NIM_BOOL T4_;
xX60gensym81_ = t;
T4_ = (NIM_BOOL)0;
T4_ = containsOrIncl__astalgo_402((&(*(*p).g).typeInfoGenerated), (NI)((NI)((NU64)(((NI) ((*xX60gensym81_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym81_).Sup.itemId.item))));
if (!T4_) goto LA5_;
goto BeforeRet_;
}
LA5_: ;
switch ((*t).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 13):
{
result = genTypeInfo__jsgen_385(p, (*t).sons->data[((NI) 0)]);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 25):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = result;
T9_[1] = rope__ropes_115(((NI64) ((*t).kind)));
s = percent___jsgen_719(T9_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 20):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s_2;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T11_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
nimZeroMem((void*)T11_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T11_[0] = result;
T11_[1] = rope__ropes_115(((NI64) ((*t).kind)));
s_2 = percent___jsgen_505(T11_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s_2);
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = result;
T13_ = NIM_NIL;
T13_ = lastSon__ast_3743(t);
T12_[1] = genTypeInfo__jsgen_385(p, T13_);
T14_ = NIM_NIL;
T14_ = percent___jsgen_543(T12_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T14_);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s_3;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T16_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
nimZeroMem((void*)T16_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T16_[0] = result;
T16_[1] = rope__ropes_115(((NI64) ((*t).kind)));
s_3 = percent___jsgen_505(T16_, 2);
prepend__ropes_265(&(*(*p).g).typeInfo, s_3);
nimZeroMem((void*)T17_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_[0] = result;
T17_[1] = genTypeInfo__jsgen_385(p, (*t).sons->data[((NI) 1)]);
T18_ = NIM_NIL;
T18_ = percent___jsgen_543(T17_, 2);
add__ropes_159(&(*(*p).g).typeInfo, T18_);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14):
{
genEnumInfo__jsgen_606(p, t, result);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17):
{
genObjectInfo__jsgen_497(p, t, result);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18):
{
genTupleInfo__jsgen_574(p, t, result);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 60):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T27_;
if (!!(((*t).n == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA25_;
T27_ = NIM_NIL;
T27_ = lastSon__ast_3743(t);
result = genTypeInfo__jsgen_385(p, T27_);
}
goto LA23_;
LA25_: ;
{
NimStringDesc* T29_;
T29_ = NIM_NIL;
T29_ = rawNewString((reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 13);
appendString(T29_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_170));
appendString(T29_, reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
appendChar(T29_, 41);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, T29_, TM__BxLwT0mhrtgTPodf1v3xjg_171);
}
LA23_: ;
}
break;
default:
{
NimStringDesc* T31_;
T31_ = NIM_NIL;
T31_ = rawNewString((reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 13);
appendString(T31_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_170));
appendString(T31_, reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
appendChar(T31_, 41);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, T31_, TM__BxLwT0mhrtgTPodf1v3xjg_172);
}
break;
}
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4002)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_176), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3949)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_178), args, argsLen_0);
return result;
}
static N_INLINE(NIM_BOOL, isEmptyType__ast_4779)(tyObject_TType__facALICuu8zUj0hjvbTLFg* t) {
NIM_BOOL result;
NIM_BOOL T1_;
result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = (t == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL));
if (T1_) goto LA2_;
T1_ = ((*t).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 63) || (*t).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 7));
LA2_: ;
result = T1_;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3938)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_179), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, createRecordVarAux__jsgen_3795)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* rec, tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* excludedFieldIDs, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** output) {
{ switch ((*rec).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 138):
{
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(rec);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA4;
i = i_2;
createRecordVarAux__jsgen_3795(p, (*rec)._kind_6.sons->data[i], excludedFieldIDs, output);
i_2 += ((NI) 1);
} LA4: ;
}
}
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 139):
{
createRecordVarAux__jsgen_3795(p, (*rec)._kind_6.sons->data[((NI) 0)], excludedFieldIDs, output);
{
NI i_3;
NI colontmp__2;
NI i_4;
i_3 = (NI)0;
colontmp__2 = (NI)0;
colontmp__2 = len__ast_3198(rec);
i_4 = ((NI) 1);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T9_;
if (!(i_4 < colontmp__2)) goto LA8;
i_3 = i_4;
T9_ = NIM_NIL;
T9_ = lastSon__ast_4832((*rec)._kind_6.sons->data[i_3]);
createRecordVarAux__jsgen_3795(p, T9_, excludedFieldIDs, output);
i_4 += ((NI) 1);
} LA8: ;
}
}
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
{
NIM_BOOL T13_;
T13_ = (NIM_BOOL)0;
T13_ = isEmptyType__ast_4779((*(*rec)._kind_4.sym).typ);
if (!T13_) goto LA14_;
goto BeforeRet_;
}
LA14_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym766_;
NIM_BOOL T18_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T26_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T28_;
xX60gensym766_ = (*rec)._kind_4.sym;
T18_ = (NIM_BOOL)0;
T18_ = contains__astalgo_3496(excludedFieldIDs, (NI)((NI)((NU64)(((NI) ((*xX60gensym766_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym766_).Sup.itemId.item))));
if (!!(T18_)) goto LA19_;
{
NI T23_;
T23_ = (NI)0;
T23_ = len__ropes_10((*output));
if (!(((NI) 0) < T23_)) goto LA24_;
add__ropes_162(output, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA24_: ;
nimZeroMem((void*)T26_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T26_[0] = mangleName__jsgen_308((*p).module, (*rec)._kind_4.sym);
T27_ = NIM_NIL;
T27_ = percent___jsgen_3938(T26_, 1);
add__ropes_159(output, T27_);
T28_ = NIM_NIL;
T28_ = createVar__jsgen_3791(p, (*(*rec)._kind_4.sym).typ, NIM_FALSE);
add__ropes_159(output, T28_);
}
LA19_: ;
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*rec).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_180), TM__BxLwT0mhrtgTPodf1v3xjg_181);
}
break;
}
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, createObjInitList__jsgen_3943)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA* excludedFieldIDs, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** output) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
t = typ;
{
NIM_BOOL T3_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
T3_ = (NIM_BOOL)0;
T3_ = objHasTypeField__jsgen_485(t);
if (!T3_) goto LA4_;
{
NI T8_;
T8_ = (NI)0;
T8_ = len__ropes_10((*output));
if (!(((NI) 0) < T8_)) goto LA9_;
add__ropes_162(output, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA9_: ;
nimZeroMem((void*)T11_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T11_[0] = genTypeInfo__jsgen_385(p, t);
T12_ = NIM_NIL;
T12_ = percent___jsgen_3949(T11_, 1);
add__ropes_159(output, T12_);
}
LA4_: ;
{
while (1) {
if (!!((t == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)))) goto LA14;
t = skipTypes__ast_3735(t, TM__BxLwT0mhrtgTPodf1v3xjg_168);
createRecordVarAux__jsgen_3795(p, (*t).n, excludedFieldIDs, output);
t = (*t).sons->data[((NI) 0)];
} LA14: ;
}
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4012)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_182), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, createVar__jsgen_3791)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, NIM_BOOL indirect) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
result = NIM_NIL;
t = skipTypes__ast_3735(typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
switch ((*t).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 35):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2):
{
{
NimStringDesc* T4_;
T4_ = NIM_NIL;
T4_ = dollar___ropes_250((*(*t).sym).loc.r);
if (!eqStrings(T4_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_102))) goto LA5_;
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_104), indirect);
}
goto LA2_;
LA5_: ;
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_105), indirect);
}
LA2_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 36) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 39):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_106), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 20):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 11):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 4):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 46):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45):
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T10_;
T10_ = NIM_NIL;
T10_ = lastSon__ast_3743(typ);
result = createVar__jsgen_3791(p, T10_, indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_107), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_49), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 5):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_67), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16):
{
NI length;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA T15_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* e;
NimStringDesc* jsTyp;
T15_ = lengthOrd__types_1661((*(*p).module).config, t);
length = toInt__int495056_170(T15_);
e = elemType__types_263(t);
jsTyp = arrayTypeForElemType__jsgen_3959(e);
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T20_;
if (!(((NI) 0) < (jsTyp ? jsTyp->Sup.len : 0))) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T20_[0] = rope__ropes_109(jsTyp);
T20_[1] = rope__ropes_115(((NI64) (length)));
result = percent___jsgen_3974(T20_, 2);
}
goto LA16_;
LA18_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T24_;
if (!(((NI) 32) < length)) goto LA22_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_140));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T24_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T24_[0] = rope__ropes_115(((NI64) (length)));
T24_[1] = createVar__jsgen_3791(p, e, NIM_FALSE);
T24_[2] = genTypeInfo__jsgen_385(p, e);
result = percent___jsgen_3979(T24_, 3);
}
goto LA16_;
LA22_: ;
{
NI i;
result = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_173));
i = ((NI) 0);
{
while (1) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T32_;
if (!(i < length)) goto LA27;
{
if (!(((NI) 0) < i)) goto LA30_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA30_: ;
T32_ = NIM_NIL;
T32_ = createVar__jsgen_3791(p, e, NIM_FALSE);
add__ropes_159(&result, T32_);
i += ((NI) 1);
} LA27: ;
}
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_174));
}
LA16_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T37_;
if (!indirect) goto LA35_;
nimZeroMem((void*)T37_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T37_[0] = result;
result = percent___jsgen_3786(T37_, 1);
}
LA35_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18):
{
result = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_175));
{
NI i_2;
NI colontmp_;
NI i_3;
i_2 = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_4002(t);
i_3 = ((NI) 0);
{
while (1) {
tyArray__mrugoXXRZUEeG9bEXo9auBKw T46_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T47_;
if (!(i_3 < colontmp_)) goto LA41;
i_2 = i_3;
{
if (!(((NI) 0) < i_2)) goto LA44_;
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA44_: ;
nimZeroMem((void*)T46_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T46_[0] = rope__ropes_115(((NI64) (i_2)));
T46_[1] = createVar__jsgen_3791(p, (*t).sons->data[i_2], NIM_FALSE);
T47_ = NIM_NIL;
T47_ = percent___jsgen_4002(T46_, 2);
add__ropes_159(&result, T47_);
i_3 += ((NI) 1);
} LA41: ;
}
}
add__ropes_162(&result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_177));
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T52_;
if (!indirect) goto LA50_;
nimZeroMem((void*)T52_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T52_[0] = result;
result = percent___jsgen_3786(T52_, 1);
}
LA50_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* initList;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA T54_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T55_;
initList = NIM_NIL;
nimZeroMem((void*)(&T54_), sizeof(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA));
initIntSet__pureZcollectionsZintsets_238((&T54_));
createObjInitList__jsgen_3943(p, t, (&T54_), &initList);
nimZeroMem((void*)T55_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T55_[0] = initList;
result = percent___jsgen_4012(T55_, 1);
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T60_;
if (!indirect) goto LA58_;
nimZeroMem((void*)T60_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T60_[0] = result;
result = percent___jsgen_3786(T60_, 1);
}
LA58_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26):
{
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T64_;
T64_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T64_ = mapType__jsgen_304(p, t);
if (!(T64_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA65_;
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_183), indirect);
}
goto LA62_;
LA65_: ;
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_67), indirect);
}
LA62_: ;
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_184), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 25):
{
result = putToSeq__jsgen_3782(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_67), indirect);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 60):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T75_;
if (!!(((*t).n == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA73_;
T75_ = NIM_NIL;
T75_ = lastSon__ast_3743(t);
result = createVar__jsgen_3791(p, T75_, indirect);
}
goto LA71_;
LA73_: ;
{
NimStringDesc* T77_;
T77_ = NIM_NIL;
T77_ = rawNewString((reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 11);
appendString(T77_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_185));
appendString(T77_, reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, T77_, TM__BxLwT0mhrtgTPodf1v3xjg_186);
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
}
LA71_: ;
}
break;
default:
{
NimStringDesc* T79_;
T79_ = NIM_NIL;
T79_ = rawNewString((reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 11);
appendString(T79_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_185));
appendString(T79_, reprEnum((NI)(*t).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, T79_, TM__BxLwT0mhrtgTPodf1v3xjg_187);
result = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, needsNoCopy__jsgen_2483)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* y) {
NIM_BOOL result;
NIM_BOOL T1_;
NIM_BOOL T3_;
NIM_BOOL T4_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T5_;
NIM_BOOL T7_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T10_;
{ result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = ((TM__BxLwT0mhrtgTPodf1v3xjg_188[(NU)((*y).kind)>>3] &(1U<<((NU)((*y).kind)&7U)))!=0);
if (T1_) goto LA2_;
T3_ = (NIM_BOOL)0;
T4_ = (NIM_BOOL)0;
T5_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T5_ = mapType__jsgen_277((*y).typ);
T4_ = !((T5_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)));
if (T4_) goto LA6_;
T7_ = (NIM_BOOL)0;
T7_ = ((*y).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3));
if (!(T7_)) goto LA8_;
T7_ = ((*(*y)._kind_4.sym).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 3));
LA8_: ;
T4_ = T7_;
LA6_: ;
T3_ = T4_;
if (!(T3_)) goto LA9_;
T10_ = NIM_NIL;
T10_ = skipTypes__ast_3735((*y).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
T3_ = ((*T10_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1) && (*T10_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2) || (*T10_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14) || (*T10_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21) && (*T10_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23) || (*T10_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 25) || (*T10_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29) || (*T10_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) && (*T10_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45) || (*T10_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47));
LA9_: ;
T1_ = T3_;
LA2_: ;
result = T1_;
goto BeforeRet_;
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4160)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_189), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_846)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_193), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, getTemp__jsgen_838)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, NIM_BOOL defineInLocals) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyArray__JiWwrsTRC6xqNlGcBthSVA T1_;
result = NIM_NIL;
(*p).unique += ((NI) 1);
nimZeroMem((void*)T1_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T1_[0] = rope__ropes_115(((NI64) ((*p).unique)));
result = percent___jsgen_846(T1_, 1);
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T8_;
if (!defineInLocals) goto LA4_;
nimZeroMem((void*)T6_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T6_[0] = result;
T7_ = NIM_NIL;
T7_ = percent___jsgen_851(T6_, 1);
T8_ = NIM_NIL;
T8_ = indentLine__jsgen_97(p, T7_);
add__ropes_159(&(*p).locals, T8_);
}
LA4_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4213)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_194), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genVarInit__jsgen_3304)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* v, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* s;
NimStringDesc* varCode;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* varName;
NIM_BOOL useReloadingGuard;
NIM_BOOL T1_;
NIM_BOOL useGlobalPragmas;
NIM_BOOL T3_;
{ nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
s = NIM_NIL;
varCode = NIM_NIL;
varName = mangleName__jsgen_308((*p).module, v);
T1_ = (NIM_BOOL)0;
T1_ = (((*v).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 3))&63U)))!=0);
if (!(T1_)) goto LA2_;
T1_ = hcrOn__options_569((*(*p).module).config);
LA2_: ;
useReloadingGuard = T1_;
T3_ = (NIM_BOOL)0;
T3_ = (((*v).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 3))&63U)))!=0);
if (!(T3_)) goto LA4_;
T3_ = !(((67110912 & (*v).flags) == 0));
LA4_: ;
useGlobalPragmas = T3_;
{
if (!((*v).constraint == 0)) goto LA7_;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
if (!useReloadingGuard) goto LA11_;
nimZeroMem((void*)T13_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T13_[0] = varName;
T14_ = NIM_NIL;
T14_ = percent___jsgen_851(T13_, 1);
T15_ = NIM_NIL;
T15_ = indentLine__jsgen_97(p, T14_);
add__ropes_159(&(*p).body, T15_);
nimZeroMem((void*)T16_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T16_[0] = varName;
T17_ = NIM_NIL;
T17_ = percent___jsgen_4072(T16_, 1);
T18_ = NIM_NIL;
T18_ = indentLine__jsgen_97(p, T17_);
add__ropes_159(&(*p).body, T18_);
varCode = dollar___ropes_250(varName);
(*p).extraIndent += ((NI) 1);
}
goto LA9_;
LA11_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T23_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T24_;
NimStringDesc* T25_;
NimStringDesc* T26_;
if (!useGlobalPragmas) goto LA20_;
nimZeroMem((void*)T22_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T22_[0] = varName;
T23_ = NIM_NIL;
T23_ = percent___jsgen_4081(T22_, 1);
T24_ = NIM_NIL;
T24_ = indentLine__jsgen_97(p, T23_);
add__ropes_159(&(*p).body, T24_);
T25_ = NIM_NIL;
T26_ = NIM_NIL;
T26_ = dollar___ropes_250(varName);
T25_ = rawNewString((T26_ ? T26_->Sup.len : 0) + 11);
appendString(T25_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_95));
appendString(T25_, T26_);
varCode = T25_;
(*p).extraIndent += ((NI) 1);
}
goto LA9_;
LA20_: ;
{
varCode = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_96));
}
LA9_: ;
}
goto LA5_;
LA7_: ;
{
varCode = copyString((*(*v).constraint)._kind_3.strVal);
}
LA5_: ;
{
if (!((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1))) goto LA31_;
{
NIM_BOOL T35_;
NIM_BOOL T36_;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym797_;
NIM_BOOL T37_;
NIM_BOOL T38_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T43_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T46_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T47_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T48_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T49_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T50_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T51_;
T35_ = (NIM_BOOL)0;
T36_ = (NIM_BOOL)0;
vX60gensym797_ = v;
T37_ = (NIM_BOOL)0;
T38_ = (NIM_BOOL)0;
T38_ = !(((131080 & (*vX60gensym797_).flags) == 0));
if (!(T38_)) goto LA39_;
T38_ = ((192 & (*vX60gensym797_).flags) == 0);
LA39_: ;
T37_ = T38_;
if (!(T37_)) goto LA40_;
T37_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym797_).kind)&31U)))!=0));
LA40_: ;
T36_ = !(T37_);
if (!(T36_)) goto LA41_;
T36_ = ((*(*v).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23) || (*(*v).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21) || (*(*v).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47) || (*(*v).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22) || (*(*v).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45));
LA41_: ;
T35_ = T36_;
if (!(T35_)) goto LA42_;
T43_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T43_ = mapType__jsgen_304(p, (*v).typ);
T35_ = (T43_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA42_: ;
if (!T35_) goto LA44_;
nimZeroMem((void*)T46_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T46_[0] = varName;
T47_ = NIM_NIL;
T47_ = percent___jsgen_4124(T46_, 1);
T48_ = NIM_NIL;
T48_ = indentLine__jsgen_97(p, T47_);
add__ropes_159(&(*p).body, T48_);
nimZeroMem((void*)T49_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T49_[0] = varName;
T50_ = NIM_NIL;
T50_ = percent___jsgen_4129(T49_, 1);
T51_ = NIM_NIL;
T51_ = indentLine__jsgen_97(p, T50_);
add__ropes_159(&(*p).body, T51_);
}
goto LA33_;
LA44_: ;
{
NimStringDesc* T53_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T54_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T55_;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym805_;
NIM_BOOL T56_;
NIM_BOOL T57_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T60_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T61_;
T53_ = NIM_NIL;
T53_ = rawNewString((varCode ? varCode->Sup.len : 0) + 8);
appendString(T53_, varCode);
appendString(T53_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_101));
nimZeroMem((void*)T54_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
nimZeroMem((void*)T55_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T54_[0] = percent___jsgen_1262(T55_, 0);
T54_[1] = varName;
vX60gensym805_ = v;
T56_ = (NIM_BOOL)0;
T57_ = (NIM_BOOL)0;
T57_ = !(((131080 & (*vX60gensym805_).flags) == 0));
if (!(T57_)) goto LA58_;
T57_ = ((192 & (*vX60gensym805_).flags) == 0);
LA58_: ;
T56_ = T57_;
if (!(T56_)) goto LA59_;
T56_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym805_).kind)&31U)))!=0));
LA59_: ;
T54_[2] = createVar__jsgen_3791(p, (*v).typ, T56_);
T60_ = NIM_NIL;
T60_ = runtimeFormat__ropes_271(T53_, T54_, 3);
T61_ = NIM_NIL;
T61_ = indentLine__jsgen_97(p, T60_);
add__ropes_159(&(*p).body, T61_);
}
LA33_: ;
}
goto LA29_;
LA31_: ;
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T63_;
gen__jsgen_766(p, n, (&a));
T63_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T63_ = mapType__jsgen_304(p, (*v).typ);
switch (T63_) {
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8):
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 4):
{
{
NIM_BOOL T67_;
T67_ = (NIM_BOOL)0;
T67_ = needsNoCopy__jsgen_2483(p, n);
if (!T67_) goto LA68_;
s = a.res;
}
goto LA65_;
LA68_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T71_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T71_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T71_[0] = a.res;
T71_[1] = genTypeInfo__jsgen_385(p, (*n).typ);
s = percent___jsgen_4160(T71_, 2);
}
LA65_: ;
}
break;
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9):
{
NIM_BOOL targetBaseIndex;
targetBaseIndex = ((131080 & (*v).flags) == 0);
{
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA75_;
{
NimStringDesc* T81_;
tyArray__f7nG5LD47BH5K9c6mASit3g T82_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T83_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T84_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T85_;
if (!targetBaseIndex) goto LA79_;
T81_ = NIM_NIL;
T81_ = rawNewString((varCode ? varCode->Sup.len : 0) + 21);
appendString(T81_, varCode);
appendString(T81_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_190));
nimZeroMem((void*)T82_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
nimZeroMem((void*)T83_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T82_[0] = percent___jsgen_1262(T83_, 0);
T82_[1] = (*v).loc.r;
T82_[2] = a.address;
T82_[3] = a.res;
T84_ = NIM_NIL;
T84_ = runtimeFormat__ropes_271(T81_, T82_, 4);
T85_ = NIM_NIL;
T85_ = indentLine__jsgen_97(p, T84_);
add__ropes_159(&(*p).body, T85_);
}
goto LA77_;
LA79_: ;
{
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym812_;
NIM_BOOL T89_;
NIM_BOOL T90_;
NimStringDesc* T95_;
tyArray__f7nG5LD47BH5K9c6mASit3g T96_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T97_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T98_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T99_;
vX60gensym812_ = v;
T89_ = (NIM_BOOL)0;
T90_ = (NIM_BOOL)0;
T90_ = !(((131080 & (*vX60gensym812_).flags) == 0));
if (!(T90_)) goto LA91_;
T90_ = ((192 & (*vX60gensym812_).flags) == 0);
LA91_: ;
T89_ = T90_;
if (!(T89_)) goto LA92_;
T89_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym812_).kind)&31U)))!=0));
LA92_: ;
if (!T89_) goto LA93_;
T95_ = NIM_NIL;
T95_ = rawNewString((varCode ? varCode->Sup.len : 0) + 16);
appendString(T95_, varCode);
appendString(T95_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_191));
nimZeroMem((void*)T96_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
nimZeroMem((void*)T97_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T96_[0] = percent___jsgen_1262(T97_, 0);
T96_[1] = (*v).loc.r;
T96_[2] = a.address;
T96_[3] = a.res;
T98_ = NIM_NIL;
T98_ = runtimeFormat__ropes_271(T95_, T96_, 4);
T99_ = NIM_NIL;
T99_ = indentLine__jsgen_97(p, T98_);
add__ropes_159(&(*p).body, T99_);
}
goto LA87_;
LA93_: ;
{
NimStringDesc* T101_;
tyArray__f7nG5LD47BH5K9c6mASit3g T102_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T103_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T104_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T105_;
T101_ = NIM_NIL;
T101_ = rawNewString((varCode ? varCode->Sup.len : 0) + 14);
appendString(T101_, varCode);
appendString(T101_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_192));
nimZeroMem((void*)T102_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
nimZeroMem((void*)T103_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T102_[0] = percent___jsgen_1262(T103_, 0);
T102_[1] = (*v).loc.r;
T102_[2] = a.address;
T102_[3] = a.res;
T104_ = NIM_NIL;
T104_ = runtimeFormat__ropes_271(T101_, T102_, 4);
T105_ = NIM_NIL;
T105_ = indentLine__jsgen_97(p, T104_);
add__ropes_159(&(*p).body, T105_);
}
LA87_: ;
}
LA77_: ;
}
goto LA73_;
LA75_: ;
{
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T111_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T112_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T113_;
if (!targetBaseIndex) goto LA109_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T111_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T111_[0] = tmp;
T111_[1] = a.res;
T111_[2] = (*v).loc.r;
T112_ = NIM_NIL;
T112_ = percent___jsgen_4213(T111_, 3);
T113_ = NIM_NIL;
T113_ = indentLine__jsgen_97(p, T112_);
add__ropes_159(&(*p).body, T113_);
}
goto LA107_;
LA109_: ;
{
NimStringDesc* T115_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T116_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T117_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T118_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T119_;
T115_ = NIM_NIL;
T115_ = rawNewString((varCode ? varCode->Sup.len : 0) + 8);
appendString(T115_, varCode);
appendString(T115_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_101));
nimZeroMem((void*)T116_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
nimZeroMem((void*)T117_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T116_[0] = percent___jsgen_1262(T117_, 0);
T116_[1] = (*v).loc.r;
T116_[2] = a.res;
T118_ = NIM_NIL;
T118_ = runtimeFormat__ropes_271(T115_, T116_, 3);
T119_ = NIM_NIL;
T119_ = indentLine__jsgen_97(p, T118_);
add__ropes_159(&(*p).body, T119_);
}
LA107_: ;
}
LA73_: ;
goto BeforeRet_;
}
break;
default:
{
s = a.res;
}
break;
}
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym825_;
NIM_BOOL T123_;
NIM_BOOL T124_;
NimStringDesc* T129_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T130_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T131_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T132_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T133_;
vX60gensym825_ = v;
T123_ = (NIM_BOOL)0;
T124_ = (NIM_BOOL)0;
T124_ = !(((131080 & (*vX60gensym825_).flags) == 0));
if (!(T124_)) goto LA125_;
T124_ = ((192 & (*vX60gensym825_).flags) == 0);
LA125_: ;
T123_ = T124_;
if (!(T123_)) goto LA126_;
T123_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym825_).kind)&31U)))!=0));
LA126_: ;
if (!T123_) goto LA127_;
T129_ = NIM_NIL;
T129_ = rawNewString((varCode ? varCode->Sup.len : 0) + 10);
appendString(T129_, varCode);
appendString(T129_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_195));
nimZeroMem((void*)T130_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
nimZeroMem((void*)T131_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T130_[0] = percent___jsgen_1262(T131_, 0);
T130_[1] = (*v).loc.r;
T130_[2] = s;
T132_ = NIM_NIL;
T132_ = runtimeFormat__ropes_271(T129_, T130_, 3);
T133_ = NIM_NIL;
T133_ = indentLine__jsgen_97(p, T132_);
add__ropes_159(&(*p).body, T133_);
}
goto LA121_;
LA127_: ;
{
NimStringDesc* T135_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T136_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T137_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T138_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T139_;
T135_ = NIM_NIL;
T135_ = rawNewString((varCode ? varCode->Sup.len : 0) + 8);
appendString(T135_, varCode);
appendString(T135_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_101));
nimZeroMem((void*)T136_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
nimZeroMem((void*)T137_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T136_[0] = percent___jsgen_1262(T137_, 0);
T136_[1] = (*v).loc.r;
T136_[2] = s;
T138_ = NIM_NIL;
T138_ = runtimeFormat__ropes_271(T135_, T136_, 3);
T139_ = NIM_NIL;
T139_ = indentLine__jsgen_97(p, T138_);
add__ropes_159(&(*p).body, T139_);
}
LA121_: ;
}
LA29_: ;
{
NIM_BOOL T142_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T146_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T147_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T148_;
T142_ = (NIM_BOOL)0;
T142_ = useReloadingGuard;
if (T142_) goto LA143_;
T142_ = useGlobalPragmas;
LA143_: ;
if (!T142_) goto LA144_;
(*p).extraIndent -= ((NI) 1);
nimZeroMem((void*)T146_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T147_ = NIM_NIL;
T147_ = percent___cgen_7505(T146_, 0);
T148_ = NIM_NIL;
T148_ = indentLine__jsgen_97(p, T147_);
add__ropes_159(&(*p).body, T148_);
}
LA144_: ;
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3298)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_198), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genCopyForParamIfNeeded__jsgen_3260)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* owner;
{ s = (*n)._kind_4.sym;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = ((*p).prc == (*s).owner);
if (T3_) goto LA4_;
T3_ = needsNoCopy__jsgen_2483(p, n);
LA4_: ;
if (!T3_) goto LA5_;
goto BeforeRet_;
}
LA5_: ;
owner = (*p).up;
{
while (1) {
{
NimStringDesc* T13_;
if (!(owner == ((tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*) NIM_NIL))) goto LA11_;
T13_ = NIM_NIL;
T13_ = rawNewString(((*(*s).name).s ? (*(*s).name).s->Sup.len : 0) + 55);
appendString(T13_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_196));
appendString(T13_, (*(*s).name).s);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T13_, TM__BxLwT0mhrtgTPodf1v3xjg_197);
}
LA11_: ;
{
if (!((*owner).prc == (*s).owner)) goto LA16_;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym679_;
NIM_BOOL T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* copy;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T23_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T24_;
xX60gensym679_ = s;
T20_ = (NIM_BOOL)0;
T20_ = containsOrIncl__astalgo_402((&(*owner).generatedParamCopies), (NI)((NI)((NU64)(((NI) ((*xX60gensym679_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym679_).Sup.itemId.item))));
if (!!(T20_)) goto LA21_;
nimZeroMem((void*)T23_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T23_[0] = (*s).loc.r;
T23_[1] = genTypeInfo__jsgen_385(p, (*s).typ);
copy = percent___jsgen_3298(T23_, 2);
T24_ = NIM_NIL;
T24_ = indentLine__jsgen_97(owner, copy);
add__ropes_159(&(*owner).locals, T24_);
}
LA21_: ;
goto BeforeRet_;
}
LA16_: ;
owner = (*owner).up;
}
}
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3364)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_199), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3369)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_200), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2827)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_201), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2822)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_202), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genConstant__jsgen_776)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* c) {
{
NIM_BOOL T3_;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym849_;
NIM_BOOL T5_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* oldBody;
T3_ = (NIM_BOOL)0;
T3_ = !((((*c).loc.flags &((NU16)1<<((NU)(((tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA) 3))&15U)))!=0));
if (!(T3_)) goto LA4_;
xX60gensym849_ = c;
T5_ = (NIM_BOOL)0;
T5_ = containsOrIncl__astalgo_402((&(*(*p).g).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym849_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym849_).Sup.itemId.item))));
T3_ = !(T5_);
LA4_: ;
if (!T3_) goto LA6_;
oldBody = (*p).body;
asgnRef((void**) (&(*p).body), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
genVarInit__jsgen_3304(p, c, (*c).ast);
add__ropes_159(&(*(*p).g).constants, (*p).body);
asgnRef((void**) (&(*p).body), oldBody);
}
LA6_: ;
}
static N_INLINE(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, getBody__modulegraphs_11241)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* g, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* result;
result = NIM_NIL;
result = (*(*s).ast)._kind_6.sons->data[((NI) 6)];
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = (result == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL));
if (!(T3_)) goto LA4_;
T3_ = ((28 &((NU8)1<<((NU)((*(*g).config).symbolFiles)&7U)))!=0);
LA4_: ;
if (!T3_) goto LA5_;
result = loadProcBody__icZic_8390((*g).config, (*g).cache, (&(*g).packed_0), s);
asgnRef((void**) (&(*(*s).ast)._kind_6.sons->data[((NI) 6)]), result);
}
LA5_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, attachProc__jsgen_3214)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* content, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s) {
add__ropes_159(&(*(*p).g).code, content);
}
N_LIB_PRIVATE N_NIMCALL(void, genProcForSymIfNeeded__jsgen_3222)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s) {
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym672_;
NIM_BOOL T3_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* newp;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* owner;
xX60gensym672_ = s;
T3_ = (NIM_BOOL)0;
T3_ = containsOrIncl__astalgo_402((&(*(*p).g).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym672_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym672_).Sup.itemId.item))));
if (!!(T3_)) goto LA4_;
newp = genProc__jsgen_773(p, s);
owner = p;
{
while (1) {
NIM_BOOL T8_;
T8_ = (NIM_BOOL)0;
T8_ = !((owner == ((tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*) NIM_NIL)));
if (!(T8_)) goto LA9_;
T8_ = !(((*owner).prc == (*s).owner));
LA9_: ;
if (!T8_) goto LA7;
owner = (*owner).up;
} LA7: ;
}
{
if (!!((owner == ((tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*) NIM_NIL)))) goto LA12_;
add__ropes_159(&(*owner).locals, newp);
}
goto LA10_;
LA12_: ;
{
attachProc__jsgen_3214(p, newp, s);
}
LA10_: ;
}
LA4_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genSym__jsgen_3308)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s;
s = (*n)._kind_4.sym;
switch ((*s).kind) {
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 8):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 9):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 3):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 5):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 11):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 21):
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA k;
{
NimStringDesc* T6_;
if (!((*s).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA4_;
T6_ = NIM_NIL;
T6_ = rawNewString(((*(*s).name).s ? (*(*s).name).s->Sup.len : 0) + 30);
appendString(T6_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_27));
appendString(T6_, (*(*s).name).s);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T6_, TM__BxLwT0mhrtgTPodf1v3xjg_28);
}
LA4_: ;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T11_;
if (!(((*s).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 28))&63U)))!=0)) goto LA9_;
T11_ = NIM_NIL;
{
if (!!(((*s).ast == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA14_;
T11_ = (*s).ast;
}
goto LA12_;
LA14_: ;
{
T11_ = newNodeI__ast_3356(((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1), (*s).info);
}
LA12_: ;
genVarInit__jsgen_3304(p, s, T11_);
}
LA9_: ;
{
if (!((*s).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 3))) goto LA19_;
genCopyForParamIfNeeded__jsgen_3260(p, n);
}
LA19_: ;
k = mapType__jsgen_304(p, (*s).typ);
{
if (!(k == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA23_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
{
if (!!(((131080 & (*s).flags) == 0))) goto LA27_;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym686_;
NIM_BOOL T31_;
NIM_BOOL T32_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T37_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T38_;
vX60gensym686_ = s;
T31_ = (NIM_BOOL)0;
T32_ = (NIM_BOOL)0;
T32_ = !(((131080 & (*vX60gensym686_).flags) == 0));
if (!(T32_)) goto LA33_;
T32_ = ((192 & (*vX60gensym686_).flags) == 0);
LA33_: ;
T31_ = T32_;
if (!(T31_)) goto LA34_;
T31_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym686_).kind)&31U)))!=0));
LA34_: ;
if (!T31_) goto LA35_;
nimZeroMem((void*)T37_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T37_[0] = (*s).loc.r;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_3364(T37_, 1));
nimZeroMem((void*)T38_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T38_[0] = (*s).loc.r;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_3369(T38_, 1));
}
goto LA29_;
LA35_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T40_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T41_;
nimZeroMem((void*)T40_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T40_[0] = (*s).loc.r;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2827(T40_, 1));
nimZeroMem((void*)T41_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T41_[0] = (*s).loc.r;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T41_, 1));
}
LA29_: ;
}
goto LA25_;
LA27_: ;
{
unsureAsgnRef((void**) (&(*r).address), (*s).loc.r);
unsureAsgnRef((void**) (&(*r).res), amp___ropes_140((*s).loc.r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_121)));
}
LA25_: ;
}
goto LA21_;
LA23_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym689_;
NIM_BOOL T44_;
NIM_BOOL T45_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T50_;
vX60gensym689_ = s;
T44_ = (NIM_BOOL)0;
T45_ = (NIM_BOOL)0;
T45_ = !(((131080 & (*vX60gensym689_).flags) == 0));
if (!(T45_)) goto LA46_;
T45_ = ((192 & (*vX60gensym689_).flags) == 0);
LA46_: ;
T44_ = T45_;
if (!(T44_)) goto LA47_;
T44_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym689_).kind)&31U)))!=0));
LA47_: ;
if (!T44_) goto LA48_;
nimZeroMem((void*)T50_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T50_[0] = (*s).loc.r;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2827(T50_, 1));
}
goto LA21_;
LA48_: ;
{
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
}
LA21_: ;
}
break;
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 10):
{
genConstant__jsgen_776(p, s);
{
NimStringDesc* T57_;
if (!((*s).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA55_;
T57_ = NIM_NIL;
T57_ = rawNewString(((*(*s).name).s ? (*(*s).name).s->Sup.len : 0) + 30);
appendString(T57_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_27));
appendString(T57_, (*(*s).name).s);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T57_, TM__BxLwT0mhrtgTPodf1v3xjg_203);
}
LA55_: ;
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
}
break;
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 12):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 13):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 16):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 14):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T64_;
{
NimStringDesc* T63_;
if (!(((*s).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 28))&63U)))!=0)) goto LA61_;
T63_ = NIM_NIL;
T63_ = rawNewString(((*(*s).name).s ? (*(*s).name).s->Sup.len : 0) + 48);
appendString(T63_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_204));
appendString(T63_, (*(*s).name).s);
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), T63_, ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 0), TM__BxLwT0mhrtgTPodf1v3xjg_205, NIM_FALSE);
}
LA61_: ;
T64_ = NIM_NIL;
T64_ = mangleName__jsgen_308((*p).module, s);
(void)(T64_);
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
{
NIM_BOOL T67_;
NIM_BOOL T68_;
T67_ = (NIM_BOOL)0;
T68_ = (NIM_BOOL)0;
T68_ = (((*s).loc.flags &((NU16)1<<((NU)(((tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA) 3))&15U)))!=0);
if (T68_) goto LA69_;
T68_ = !(((*s).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 0) || (*s).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 155)));
LA69_: ;
T67_ = T68_;
if (T67_) goto LA70_;
T67_ = !(((IL64(4294967360) & (*s).flags) == 0));
LA70_: ;
if (!T67_) goto LA71_;
}
goto LA65_;
LA71_: ;
{
NIM_BOOL T74_;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T76_;
T74_ = (NIM_BOOL)0;
T74_ = ((*s).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 14));
if (!(T74_)) goto LA75_;
T76_ = NIM_NIL;
T76_ = getBody__modulegraphs_11241((*(*p).module).graph, s);
T74_ = ((*T76_).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1));
LA75_: ;
if (!T74_) goto LA77_;
}
goto LA65_;
LA77_: ;
{
NI T82_;
if (!(((*s).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 4))&63U)))!=0)) goto LA80_;
asgnRef((void**) (&(*(*p).g).forwarded), (tySequence__eHqUwlHGGaPw0TDPDeL79cQ*) incrSeqV3((TGenericSeq*)((*(*p).g).forwarded), (&NTIseqLpsymT__eHqUwlHGGaPw0TDPDeL79cQ_)));
T82_ = (*(*p).g).forwarded->Sup.len++;
asgnRef((void**) (&(*(*p).g).forwarded->data[T82_]), s);
}
goto LA65_;
LA80_: ;
{
genProcForSymIfNeeded__jsgen_3222(p, s);
}
LA65_: ;
}
break;
default:
{
{
NimStringDesc* T89_;
if (!((*s).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA87_;
T89_ = NIM_NIL;
T89_ = rawNewString(((*(*s).name).s ? (*(*s).name).s->Sup.len : 0) + 30);
appendString(T89_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_27));
appendString(T89_, (*(*s).name).s);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T89_, TM__BxLwT0mhrtgTPodf1v3xjg_206);
}
LA87_: ;
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
}
break;
}
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6385)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_213), args, argsLen_0);
return result;
}
static N_INLINE(NIM_BOOL, signbit__astalgo_926)(NF x) {
NIM_BOOL result;
int T1_;
result = (NIM_BOOL)0;
T1_ = (int)0;
T1_ = signbit(x);
result = !((T1_ == ((NI32) 0)));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1834)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_221), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genLineDir__jsgen_1818)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NI line;
{ line = toLinenumber__msgs_609((*n).info);
{
if (!(line < ((NI) 0))) goto LA3_;
goto BeforeRet_;
}
LA3_: ;
{
NIM_BOOL T7_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T13_;
T7_ = (NIM_BOOL)0;
T7_ = (((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 12))&31U)))!=0);
if (T7_) goto LA8_;
T7_ = (((*(*(*p).module).config).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 12))&31U)))!=0);
LA8_: ;
if (!T7_) goto LA9_;
nimZeroMem((void*)T11_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T11_[0] = lineDir__jsgen_1808((*(*p).module).config, (*n).info, line);
T12_ = NIM_NIL;
T12_ = percent___cgen_19262(T11_, 1);
T13_ = NIM_NIL;
T13_ = indentLine__jsgen_97(p, T12_);
add__ropes_159(&(*p).body, T13_);
}
LA9_: ;
{
NIM_BOOL T16_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
T16_ = (NIM_BOOL)0;
T16_ = hasFrameInfo__jsgen_1789(p);
if (!T16_) goto LA17_;
nimZeroMem((void*)T19_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T19_[0] = rope__ropes_115(((NI64) (line)));
T20_ = NIM_NIL;
T20_ = percent___jsgen_1834(T19_, 1);
T21_ = NIM_NIL;
T21_ = indentLine__jsgen_97(p, T20_);
add__ropes_159(&(*p).body, T21_);
}
LA17_: ;
}BeforeRet_: ;
}
static N_INLINE(NIM_BOOL, isAtom__ast_4768)(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NIM_BOOL result;
NIM_BOOL T1_;
result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = (((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 0) <= (*n).kind);
if (!(T1_)) goto LA2_;
T1_ = ((*n).kind <= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 23));
LA2_: ;
result = T1_;
return result;
}
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, isSimpleExpr__jsgen_821)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NIM_BOOL result;
{ result = (NIM_BOOL)0;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = ((*n).kind >= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) && (*n).kind <= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 37) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 42) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 45) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 160));
if (T3_) goto LA4_;
T3_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 38) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 41) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 39));
LA4_: ;
if (!T3_) goto LA5_;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* c;
c = NIM_NIL;
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = safeLen__ast_3191(n);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA10;
i = i_2;
c = (*n)._kind_6.sons->data[i];
{
NIM_BOOL T13_;
T13_ = (NIM_BOOL)0;
T13_ = isSimpleExpr__jsgen_821(p, c);
if (!!(T13_)) goto LA14_;
result = NIM_FALSE;
goto BeforeRet_;
}
LA14_: ;
i_2 += ((NI) 1);
} LA10: ;
}
}
}
result = NIM_TRUE;
}
goto LA1_;
LA5_: ;
{
NIM_BOOL T17_;
T17_ = (NIM_BOOL)0;
T17_ = isAtom__ast_4768(n);
if (!T17_) goto LA18_;
result = NIM_TRUE;
}
goto LA1_;
LA18_: ;
LA1_: ;
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_917)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_222), args, argsLen_0);
return result;
}
static N_INLINE(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, rdLoc__jsgen_188)(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* a) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
{
if (!!(((*a).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)))) goto LA3_;
result = (*a).res;
}
goto LA1_;
LA3_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T6_;
nimZeroMem((void*)T6_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T6_[0] = (*a).address;
T6_[1] = (*a).res;
result = percent___cgen_6775(T6_, 2);
}
LA1_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_922)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_223), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_885)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_224), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genOr__jsgen_903)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* a, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
{
NIM_BOOL T3_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T7_;
T3_ = (NIM_BOOL)0;
T3_ = isSimpleExpr__jsgen_821(p, a);
if (!(T3_)) goto LA4_;
T3_ = isSimpleExpr__jsgen_821(p, b);
LA4_: ;
if (!T3_) goto LA5_;
gen__jsgen_766(p, a, (&x));
gen__jsgen_766(p, b, (&y));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
nimZeroMem((void*)T7_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T7_[0] = rdLoc__jsgen_188((&x));
T7_[1] = rdLoc__jsgen_188((&y));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_917(T7_, 2));
}
goto LA1_;
LA5_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T16_;
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
gen__jsgen_766(p, a, (&x));
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = rdLoc__jsgen_188((&x));
T9_[1] = rdLoc__jsgen_188((&(*r)));
T10_ = NIM_NIL;
T10_ = percent___jsgen_922(T9_, 2);
T11_ = NIM_NIL;
T11_ = indentLine__jsgen_97(p, T10_);
add__ropes_159(&(*p).body, T11_);
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, b, (&y));
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = rdLoc__jsgen_188((&y));
T12_[1] = rdLoc__jsgen_188((&(*r)));
T13_ = NIM_NIL;
T13_ = percent___jsgen_885(T12_, 2);
T14_ = NIM_NIL;
T14_ = indentLine__jsgen_97(p, T13_);
add__ropes_159(&(*p).body, T14_);
(*p).extraIndent -= ((NI) 1);
T15_ = NIM_NIL;
T15_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_177));
T16_ = NIM_NIL;
T16_ = indentLine__jsgen_97(p, T15_);
add__ropes_159(&(*p).body, T16_);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_871)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_225), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_876)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_226), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genAnd__jsgen_856)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* a, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
{
NIM_BOOL T3_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T7_;
T3_ = (NIM_BOOL)0;
T3_ = isSimpleExpr__jsgen_821(p, a);
if (!(T3_)) goto LA4_;
T3_ = isSimpleExpr__jsgen_821(p, b);
LA4_: ;
if (!T3_) goto LA5_;
gen__jsgen_766(p, a, (&x));
gen__jsgen_766(p, b, (&y));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
nimZeroMem((void*)T7_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T7_[0] = rdLoc__jsgen_188((&x));
T7_[1] = rdLoc__jsgen_188((&y));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_871(T7_, 2));
}
goto LA1_;
LA5_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T16_;
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
gen__jsgen_766(p, a, (&x));
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = rdLoc__jsgen_188((&x));
T9_[1] = rdLoc__jsgen_188((&(*r)));
T10_ = NIM_NIL;
T10_ = percent___jsgen_876(T9_, 2);
T11_ = NIM_NIL;
T11_ = indentLine__jsgen_97(p, T10_);
add__ropes_159(&(*p).body, T11_);
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, b, (&y));
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = rdLoc__jsgen_188((&y));
T12_[1] = rdLoc__jsgen_188((&(*r)));
T13_ = NIM_NIL;
T13_ = percent___jsgen_885(T12_, 2);
T14_ = NIM_NIL;
T14_ = indentLine__jsgen_97(p, T13_);
add__ropes_159(&(*p).body, T14_);
(*p).extraIndent -= ((NI) 1);
T15_ = NIM_NIL;
T15_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_177));
T16_ = NIM_NIL;
T16_ = indentLine__jsgen_97(p, T15_);
add__ropes_159(&(*p).body, T16_);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, unsignedTrimmerJS__jsgen_1101)(NI64 size) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
switch (size) {
case ((NI) 1):
{
result = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_227));
}
break;
case ((NI) 2):
{
result = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_228));
}
break;
case ((NI) 4):
{
result = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_229));
}
break;
default:
{
result = rope__ropes_109(((NimStringDesc*) NIM_NIL));
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1734)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_230), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, binaryUintExpr__jsgen_1721)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* op) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* trimmer;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
tyArray__f7nG5LD47BH5K9c6mASit3g T2_;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, abstractRange__types_101);
trimmer = unsignedTrimmerJS__jsgen_1101((*T1_).size);
nimZeroMem((void*)T2_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T2_[0] = rdLoc__jsgen_188((&x));
T2_[1] = rope__ropes_109(op);
T2_[2] = rdLoc__jsgen_188((&y));
T2_[3] = trimmer;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1734(T2_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1761)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_236), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1163)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_250), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1168)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_251), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1173)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_252), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1178)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_253), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1183)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_254), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1188)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_255), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1193)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_256), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1198)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_257), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1203)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_258), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1208)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_259), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1253)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_260), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1272)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_261), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1281)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_262), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1291)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_263), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1300)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_264), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1309)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_265), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1318)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_266), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1327)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_267), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1336)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_268), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1345)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_269), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1386)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_270), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1579)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_271), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1588)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_272), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1597)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_273), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1602)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_274), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1615)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_275), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1624)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_276), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1649)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_277), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1658)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_278), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1667)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_279), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1684)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_280), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, arithAux__jsgen_1135)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg op) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* xLoc;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* yLoc;
NI i;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
xLoc = NIM_NIL;
yLoc = NIM_NIL;
i = !((((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 5))&31U)))!=0));
useMagic__jsgen_779(p, jsMagics__jsgen_941[(op)- 46][(i)- 0]);
{
NI T3_;
T3_ = (NI)0;
T3_ = len__ast_3198(n);
if (!(((NI) 2) < T3_)) goto LA4_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
xLoc = rdLoc__jsgen_188((&x));
yLoc = rdLoc__jsgen_188((&y));
}
goto LA1_;
LA4_: ;
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
xLoc = rdLoc__jsgen_188((&(*r)));
}
LA1_: ;
switch (op) {
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 46):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
if (!(i == ((NI) 0))) goto LA10_;
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = xLoc;
T12_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1163(T12_, 2));
}
goto LA8_;
LA10_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T14_;
nimZeroMem((void*)T14_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T14_[0] = xLoc;
T14_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1168(T14_, 2));
}
LA8_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 47):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T20_;
if (!(i == ((NI) 0))) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T20_[0] = xLoc;
T20_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1173(T20_, 2));
}
goto LA16_;
LA18_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T22_;
nimZeroMem((void*)T22_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T22_[0] = xLoc;
T22_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1178(T22_, 2));
}
LA16_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 48):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T28_;
if (!(i == ((NI) 0))) goto LA26_;
nimZeroMem((void*)T28_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T28_[0] = xLoc;
T28_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1183(T28_, 2));
}
goto LA24_;
LA26_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T30_;
nimZeroMem((void*)T30_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T30_[0] = xLoc;
T30_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1188(T30_, 2));
}
LA24_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 49):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T36_;
if (!(i == ((NI) 0))) goto LA34_;
nimZeroMem((void*)T36_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T36_[0] = xLoc;
T36_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1193(T36_, 2));
}
goto LA32_;
LA34_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T38_;
nimZeroMem((void*)T38_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T38_[0] = xLoc;
T38_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1198(T38_, 2));
}
LA32_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 50):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T44_;
if (!(i == ((NI) 0))) goto LA42_;
nimZeroMem((void*)T44_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T44_[0] = xLoc;
T44_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1203(T44_, 2));
}
goto LA40_;
LA42_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T46_;
nimZeroMem((void*)T46_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T46_[0] = xLoc;
T46_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1208(T46_, 2));
}
LA40_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 51):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T52_;
if (!(i == ((NI) 0))) goto LA50_;
nimZeroMem((void*)T52_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T52_[0] = xLoc;
T52_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1163(T52_, 2));
}
goto LA48_;
LA50_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T54_;
nimZeroMem((void*)T54_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T54_[0] = xLoc;
T54_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1168(T54_, 2));
}
LA48_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 52):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T60_;
if (!(i == ((NI) 0))) goto LA58_;
nimZeroMem((void*)T60_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T60_[0] = xLoc;
T60_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1173(T60_, 2));
}
goto LA56_;
LA58_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T62_;
nimZeroMem((void*)T62_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T62_[0] = xLoc;
T62_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1178(T62_, 2));
}
LA56_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 53):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T68_;
if (!(i == ((NI) 0))) goto LA66_;
nimZeroMem((void*)T68_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T68_[0] = xLoc;
T68_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1168(T68_, 2));
}
goto LA64_;
LA66_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T70_;
nimZeroMem((void*)T70_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T70_[0] = xLoc;
T70_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1168(T70_, 2));
}
LA64_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 54):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T76_;
if (!(i == ((NI) 0))) goto LA74_;
nimZeroMem((void*)T76_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T76_[0] = xLoc;
T76_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1178(T76_, 2));
}
goto LA72_;
LA74_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T78_;
nimZeroMem((void*)T78_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T78_[0] = xLoc;
T78_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1178(T78_, 2));
}
LA72_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 55):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T84_;
if (!(i == ((NI) 0))) goto LA82_;
nimZeroMem((void*)T84_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T84_[0] = xLoc;
T84_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1188(T84_, 2));
}
goto LA80_;
LA82_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T86_;
nimZeroMem((void*)T86_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T86_[0] = xLoc;
T86_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1188(T86_, 2));
}
LA80_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 56):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T92_;
if (!(i == ((NI) 0))) goto LA90_;
nimZeroMem((void*)T92_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T92_[0] = xLoc;
T92_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1253(T92_, 2));
}
goto LA88_;
LA90_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T94_;
nimZeroMem((void*)T94_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T94_[0] = xLoc;
T94_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1253(T94_, 2));
}
LA88_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 57):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T100_;
if (!(i == ((NI) 0))) goto LA98_;
nimZeroMem((void*)T100_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T100_[0] = xLoc;
T100_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T100_, 2));
}
goto LA96_;
LA98_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T102_;
nimZeroMem((void*)T102_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T102_[0] = xLoc;
T102_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T102_, 2));
}
LA96_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 58):
{
{
if (!((*(*(*n)._kind_6.sons->data[((NI) 1)]).typ).size <= IL64(4))) goto LA106_;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T112_;
if (!(i == ((NI) 0))) goto LA110_;
nimZeroMem((void*)T112_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T112_[0] = xLoc;
T112_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1272(T112_, 2));
}
goto LA108_;
LA110_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T114_;
nimZeroMem((void*)T114_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T114_[0] = xLoc;
T114_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1272(T114_, 2));
}
LA108_: ;
}
goto LA104_;
LA106_: ;
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T120_;
if (!(i == ((NI) 0))) goto LA118_;
nimZeroMem((void*)T120_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T120_[0] = xLoc;
T120_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1281(T120_, 2));
}
goto LA116_;
LA118_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T122_;
nimZeroMem((void*)T122_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T122_[0] = xLoc;
T122_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1281(T122_, 2));
}
LA116_: ;
}
LA104_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 59):
{
{
if (!((*(*(*n)._kind_6.sons->data[((NI) 1)]).typ).size <= IL64(4))) goto LA126_;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T132_;
if (!(i == ((NI) 0))) goto LA130_;
nimZeroMem((void*)T132_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T132_[0] = xLoc;
T132_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1291(T132_, 2));
}
goto LA128_;
LA130_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T134_;
nimZeroMem((void*)T134_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T134_[0] = xLoc;
T134_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1291(T134_, 2));
}
LA128_: ;
}
goto LA124_;
LA126_: ;
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T140_;
if (!(i == ((NI) 0))) goto LA138_;
nimZeroMem((void*)T140_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T140_[0] = xLoc;
T140_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1300(T140_, 2));
}
goto LA136_;
LA138_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T142_;
nimZeroMem((void*)T142_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T142_[0] = xLoc;
T142_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1300(T142_, 2));
}
LA136_: ;
}
LA124_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 60):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T148_;
if (!(i == ((NI) 0))) goto LA146_;
nimZeroMem((void*)T148_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T148_[0] = xLoc;
T148_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1309(T148_, 2));
}
goto LA144_;
LA146_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T150_;
nimZeroMem((void*)T150_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T150_[0] = xLoc;
T150_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1309(T150_, 2));
}
LA144_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 61):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T156_;
if (!(i == ((NI) 0))) goto LA154_;
nimZeroMem((void*)T156_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T156_[0] = xLoc;
T156_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1318(T156_, 2));
}
goto LA152_;
LA154_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T158_;
nimZeroMem((void*)T158_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T158_[0] = xLoc;
T158_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1318(T158_, 2));
}
LA152_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 62):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T164_;
if (!(i == ((NI) 0))) goto LA162_;
nimZeroMem((void*)T164_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T164_[0] = xLoc;
T164_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1327(T164_, 2));
}
goto LA160_;
LA162_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T166_;
nimZeroMem((void*)T166_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T166_[0] = xLoc;
T166_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1327(T166_, 2));
}
LA160_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 63):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T172_;
if (!(i == ((NI) 0))) goto LA170_;
nimZeroMem((void*)T172_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T172_[0] = xLoc;
T172_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1336(T172_, 2));
}
goto LA168_;
LA170_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T174_;
nimZeroMem((void*)T174_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T174_[0] = xLoc;
T174_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1336(T174_, 2));
}
LA168_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 64):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T180_;
if (!(i == ((NI) 0))) goto LA178_;
nimZeroMem((void*)T180_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T180_[0] = xLoc;
T180_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1345(T180_, 2));
}
goto LA176_;
LA178_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T182_;
nimZeroMem((void*)T182_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T182_[0] = xLoc;
T182_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1345(T182_, 2));
}
LA176_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 65):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T188_;
if (!(i == ((NI) 0))) goto LA186_;
nimZeroMem((void*)T188_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T188_[0] = xLoc;
T188_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T188_, 2));
}
goto LA184_;
LA186_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T190_;
nimZeroMem((void*)T190_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T190_[0] = xLoc;
T190_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T190_, 2));
}
LA184_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 66):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T196_;
if (!(i == ((NI) 0))) goto LA194_;
nimZeroMem((void*)T196_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T196_[0] = xLoc;
T196_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T196_, 2));
}
goto LA192_;
LA194_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T198_;
nimZeroMem((void*)T198_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T198_[0] = xLoc;
T198_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T198_, 2));
}
LA192_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 67):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T204_;
if (!(i == ((NI) 0))) goto LA202_;
nimZeroMem((void*)T204_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T204_[0] = xLoc;
T204_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T204_, 2));
}
goto LA200_;
LA202_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T206_;
nimZeroMem((void*)T206_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T206_[0] = xLoc;
T206_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T206_, 2));
}
LA200_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 68):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T212_;
if (!(i == ((NI) 0))) goto LA210_;
nimZeroMem((void*)T212_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T212_[0] = xLoc;
T212_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T212_, 2));
}
goto LA208_;
LA210_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T214_;
nimZeroMem((void*)T214_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T214_[0] = xLoc;
T214_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1262(T214_, 2));
}
LA208_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 69):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T220_;
if (!(i == ((NI) 0))) goto LA218_;
nimZeroMem((void*)T220_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T220_[0] = xLoc;
T220_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1386(T220_, 2));
}
goto LA216_;
LA218_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T222_;
nimZeroMem((void*)T222_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T222_[0] = xLoc;
T222_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1386(T222_, 2));
}
LA216_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 70):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T228_;
if (!(i == ((NI) 0))) goto LA226_;
nimZeroMem((void*)T228_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T228_[0] = xLoc;
T228_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T228_, 2));
}
goto LA224_;
LA226_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T230_;
nimZeroMem((void*)T230_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T230_[0] = xLoc;
T230_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T230_, 2));
}
LA224_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 71):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T236_;
if (!(i == ((NI) 0))) goto LA234_;
nimZeroMem((void*)T236_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T236_[0] = xLoc;
T236_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T236_, 2));
}
goto LA232_;
LA234_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T238_;
nimZeroMem((void*)T238_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T238_[0] = xLoc;
T238_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T238_, 2));
}
LA232_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 72):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T244_;
if (!(i == ((NI) 0))) goto LA242_;
nimZeroMem((void*)T244_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T244_[0] = xLoc;
T244_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T244_, 2));
}
goto LA240_;
LA242_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T246_;
nimZeroMem((void*)T246_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T246_[0] = xLoc;
T246_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T246_, 2));
}
LA240_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 73):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T252_;
if (!(i == ((NI) 0))) goto LA250_;
nimZeroMem((void*)T252_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T252_[0] = xLoc;
T252_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T252_, 2));
}
goto LA248_;
LA250_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T254_;
nimZeroMem((void*)T254_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T254_[0] = xLoc;
T254_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T254_, 2));
}
LA248_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 74):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T260_;
if (!(i == ((NI) 0))) goto LA258_;
nimZeroMem((void*)T260_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T260_[0] = xLoc;
T260_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T260_, 2));
}
goto LA256_;
LA258_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T262_;
nimZeroMem((void*)T262_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T262_[0] = xLoc;
T262_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T262_, 2));
}
LA256_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 75):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T268_;
if (!(i == ((NI) 0))) goto LA266_;
nimZeroMem((void*)T268_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T268_[0] = xLoc;
T268_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T268_, 2));
}
goto LA264_;
LA266_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T270_;
nimZeroMem((void*)T270_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T270_[0] = xLoc;
T270_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T270_, 2));
}
LA264_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 76):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T276_;
if (!(i == ((NI) 0))) goto LA274_;
nimZeroMem((void*)T276_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T276_[0] = xLoc;
T276_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T276_, 2));
}
goto LA272_;
LA274_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T278_;
nimZeroMem((void*)T278_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T278_[0] = xLoc;
T278_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T278_, 2));
}
LA272_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 77):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T284_;
if (!(i == ((NI) 0))) goto LA282_;
nimZeroMem((void*)T284_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T284_[0] = xLoc;
T284_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T284_, 2));
}
goto LA280_;
LA282_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T286_;
nimZeroMem((void*)T286_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T286_[0] = xLoc;
T286_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T286_, 2));
}
LA280_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 78):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T292_;
if (!(i == ((NI) 0))) goto LA290_;
nimZeroMem((void*)T292_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T292_[0] = xLoc;
T292_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T292_, 2));
}
goto LA288_;
LA290_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T294_;
nimZeroMem((void*)T294_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T294_[0] = xLoc;
T294_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T294_, 2));
}
LA288_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 79):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T300_;
if (!(i == ((NI) 0))) goto LA298_;
nimZeroMem((void*)T300_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T300_[0] = xLoc;
T300_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T300_, 2));
}
goto LA296_;
LA298_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T302_;
nimZeroMem((void*)T302_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T302_[0] = xLoc;
T302_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T302_, 2));
}
LA296_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 80):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T308_;
if (!(i == ((NI) 0))) goto LA306_;
nimZeroMem((void*)T308_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T308_[0] = xLoc;
T308_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T308_, 2));
}
goto LA304_;
LA306_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T310_;
nimZeroMem((void*)T310_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T310_[0] = xLoc;
T310_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T310_, 2));
}
LA304_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 81):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T316_;
if (!(i == ((NI) 0))) goto LA314_;
nimZeroMem((void*)T316_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T316_[0] = xLoc;
T316_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T316_, 2));
}
goto LA312_;
LA314_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T318_;
nimZeroMem((void*)T318_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T318_[0] = xLoc;
T318_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T318_, 2));
}
LA312_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 82):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T324_;
if (!(i == ((NI) 0))) goto LA322_;
nimZeroMem((void*)T324_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T324_[0] = xLoc;
T324_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T324_, 2));
}
goto LA320_;
LA322_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T326_;
nimZeroMem((void*)T326_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T326_[0] = xLoc;
T326_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T326_, 2));
}
LA320_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 83):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T332_;
if (!(i == ((NI) 0))) goto LA330_;
nimZeroMem((void*)T332_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T332_[0] = xLoc;
T332_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T332_, 2));
}
goto LA328_;
LA330_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T334_;
nimZeroMem((void*)T334_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T334_[0] = xLoc;
T334_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T334_, 2));
}
LA328_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 84):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T340_;
if (!(i == ((NI) 0))) goto LA338_;
nimZeroMem((void*)T340_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T340_[0] = xLoc;
T340_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T340_, 2));
}
goto LA336_;
LA338_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T342_;
nimZeroMem((void*)T342_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T342_[0] = xLoc;
T342_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T342_, 2));
}
LA336_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 85):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T348_;
if (!(i == ((NI) 0))) goto LA346_;
nimZeroMem((void*)T348_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T348_[0] = xLoc;
T348_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T348_, 2));
}
goto LA344_;
LA346_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T350_;
nimZeroMem((void*)T350_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T350_[0] = xLoc;
T350_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T350_, 2));
}
LA344_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 86):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T356_;
if (!(i == ((NI) 0))) goto LA354_;
nimZeroMem((void*)T356_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T356_[0] = xLoc;
T356_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T356_, 2));
}
goto LA352_;
LA354_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T358_;
nimZeroMem((void*)T358_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T358_[0] = xLoc;
T358_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T358_, 2));
}
LA352_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 87):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T364_;
if (!(i == ((NI) 0))) goto LA362_;
nimZeroMem((void*)T364_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T364_[0] = xLoc;
T364_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T364_, 2));
}
goto LA360_;
LA362_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T366_;
nimZeroMem((void*)T366_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T366_[0] = xLoc;
T366_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T366_, 2));
}
LA360_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 88):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T372_;
if (!(i == ((NI) 0))) goto LA370_;
nimZeroMem((void*)T372_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T372_[0] = xLoc;
T372_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T372_, 2));
}
goto LA368_;
LA370_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T374_;
nimZeroMem((void*)T374_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T374_[0] = xLoc;
T374_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19070(T374_, 2));
}
LA368_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 89):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T380_;
if (!(i == ((NI) 0))) goto LA378_;
nimZeroMem((void*)T380_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T380_[0] = xLoc;
T380_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T380_, 2));
}
goto LA376_;
LA378_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T382_;
nimZeroMem((void*)T382_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T382_[0] = xLoc;
T382_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19075(T382_, 2));
}
LA376_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 90):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T388_;
if (!(i == ((NI) 0))) goto LA386_;
nimZeroMem((void*)T388_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T388_[0] = xLoc;
T388_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19153(T388_, 2));
}
goto LA384_;
LA386_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T390_;
nimZeroMem((void*)T390_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T390_[0] = xLoc;
T390_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19153(T390_, 2));
}
LA384_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 91):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T396_;
if (!(i == ((NI) 0))) goto LA394_;
nimZeroMem((void*)T396_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T396_[0] = xLoc;
T396_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T396_, 2));
}
goto LA392_;
LA394_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T398_;
nimZeroMem((void*)T398_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T398_[0] = xLoc;
T398_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T398_, 2));
}
LA392_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 92):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T404_;
if (!(i == ((NI) 0))) goto LA402_;
nimZeroMem((void*)T404_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T404_[0] = xLoc;
T404_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T404_, 2));
}
goto LA400_;
LA402_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T406_;
nimZeroMem((void*)T406_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T406_[0] = xLoc;
T406_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19065(T406_, 2));
}
LA400_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 93):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T412_;
if (!(i == ((NI) 0))) goto LA410_;
nimZeroMem((void*)T412_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T412_[0] = xLoc;
T412_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1579(T412_, 2));
}
goto LA408_;
LA410_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T414_;
nimZeroMem((void*)T414_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T414_[0] = xLoc;
T414_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_18935(T414_, 2));
}
LA408_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 94):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T420_;
if (!(i == ((NI) 0))) goto LA418_;
nimZeroMem((void*)T420_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T420_[0] = xLoc;
T420_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1588(T420_, 2));
}
goto LA416_;
LA418_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T422_;
nimZeroMem((void*)T422_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T422_[0] = xLoc;
T422_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_18935(T422_, 2));
}
LA416_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 95):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T428_;
if (!(i == ((NI) 0))) goto LA426_;
nimZeroMem((void*)T428_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T428_[0] = xLoc;
T428_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1597(T428_, 2));
}
goto LA424_;
LA426_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T430_;
nimZeroMem((void*)T430_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T430_[0] = xLoc;
T430_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1602(T430_, 2));
}
LA424_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 96):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T436_;
if (!(i == ((NI) 0))) goto LA434_;
nimZeroMem((void*)T436_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T436_[0] = xLoc;
T436_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19257(T436_, 2));
}
goto LA432_;
LA434_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T438_;
nimZeroMem((void*)T438_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T438_[0] = xLoc;
T438_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19257(T438_, 2));
}
LA432_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 97):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T444_;
if (!(i == ((NI) 0))) goto LA442_;
nimZeroMem((void*)T444_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T444_[0] = xLoc;
T444_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1615(T444_, 2));
}
goto LA440_;
LA442_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T446_;
nimZeroMem((void*)T446_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T446_[0] = xLoc;
T446_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1615(T446_, 2));
}
LA440_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 98):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T452_;
if (!(i == ((NI) 0))) goto LA450_;
nimZeroMem((void*)T452_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T452_[0] = xLoc;
T452_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1624(T452_, 2));
}
goto LA448_;
LA450_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T454_;
nimZeroMem((void*)T454_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T454_[0] = xLoc;
T454_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1624(T454_, 2));
}
LA448_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 99):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T460_;
if (!(i == ((NI) 0))) goto LA458_;
nimZeroMem((void*)T460_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T460_[0] = xLoc;
T460_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1615(T460_, 2));
}
goto LA456_;
LA458_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T462_;
nimZeroMem((void*)T462_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T462_[0] = xLoc;
T462_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1615(T462_, 2));
}
LA456_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 100):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T468_;
if (!(i == ((NI) 0))) goto LA466_;
nimZeroMem((void*)T468_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T468_[0] = xLoc;
T468_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_18935(T468_, 2));
}
goto LA464_;
LA466_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T470_;
nimZeroMem((void*)T470_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T470_[0] = xLoc;
T470_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_18935(T470_, 2));
}
LA464_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 101):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T476_;
if (!(i == ((NI) 0))) goto LA474_;
nimZeroMem((void*)T476_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T476_[0] = xLoc;
T476_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1649(T476_, 2));
}
goto LA472_;
LA474_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T478_;
nimZeroMem((void*)T478_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T478_[0] = xLoc;
T478_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1649(T478_, 2));
}
LA472_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 102):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T484_;
if (!(i == ((NI) 0))) goto LA482_;
nimZeroMem((void*)T484_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T484_[0] = xLoc;
T484_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1658(T484_, 2));
}
goto LA480_;
LA482_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T486_;
nimZeroMem((void*)T486_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T486_[0] = xLoc;
T486_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1658(T486_, 2));
}
LA480_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 103):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T492_;
if (!(i == ((NI) 0))) goto LA490_;
nimZeroMem((void*)T492_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T492_[0] = xLoc;
T492_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1667(T492_, 2));
}
goto LA488_;
LA490_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T494_;
nimZeroMem((void*)T494_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T494_[0] = xLoc;
T494_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1667(T494_, 2));
}
LA488_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 104):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T500_;
if (!(i == ((NI) 0))) goto LA498_;
nimZeroMem((void*)T500_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T500_[0] = xLoc;
T500_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1667(T500_, 2));
}
goto LA496_;
LA498_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T502_;
nimZeroMem((void*)T502_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T502_[0] = xLoc;
T502_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1667(T502_, 2));
}
LA496_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 106):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T508_;
if (!(i == ((NI) 0))) goto LA506_;
nimZeroMem((void*)T508_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T508_[0] = xLoc;
T508_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1684(T508_, 2));
}
goto LA504_;
LA506_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T510_;
nimZeroMem((void*)T510_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T510_[0] = xLoc;
T510_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1684(T510_, 2));
}
LA504_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 107):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 153):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 155):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 154):
{
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T516_;
if (!(i == ((NI) 0))) goto LA514_;
nimZeroMem((void*)T516_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T516_[0] = xLoc;
T516_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19262(T516_, 2));
}
goto LA512_;
LA514_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T518_;
nimZeroMem((void*)T518_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T518_[0] = xLoc;
T518_[1] = yLoc;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_19262(T518_, 2));
}
LA512_: ;
}
break;
default:
{
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1770)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_281), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1784)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_282), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, arith__jsgen_1716)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg op) {
switch (op) {
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 65):
{
binaryUintExpr__jsgen_1721(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_231));
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 66):
{
binaryUintExpr__jsgen_1721(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_232));
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 67):
{
binaryUintExpr__jsgen_1721(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_233));
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 68):
{
binaryUintExpr__jsgen_1721(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_234));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T7_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
T7_ = NIM_NIL;
T7_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_235);
if (!((*T7_).size == IL64(8))) goto LA8_;
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1761(T10_, 1));
}
LA8_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 49):
{
arithAux__jsgen_1135(p, n, r, op);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 50):
{
arithAux__jsgen_1135(p, n, r, op);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 57):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T14_;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
nimZeroMem((void*)T14_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T14_[0] = rdLoc__jsgen_188((&x));
T14_[1] = rdLoc__jsgen_188((&y));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1770(T14_, 2));
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 101):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 102):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 103):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 104):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 106):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 107):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 108):
{
arithAux__jsgen_1135(p, n, r, op);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 87):
{
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T19_;
T19_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T19_ = mapType__jsgen_277((*(*n)._kind_6.sons->data[((NI) 1)]).typ);
if (!!((T19_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)))) goto LA20_;
arithAux__jsgen_1135(p, n, r, op);
}
goto LA17_;
LA20_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_2;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y_2;
tyArray__f7nG5LD47BH5K9c6mASit3g T23_;
nimZeroMem((void*)(&x_2), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y_2), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_2));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y_2));
nimZeroMem((void*)T23_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T23_[0] = x_2.address;
T23_[1] = y_2.address;
T23_[2] = x_2.res;
T23_[3] = y_2.res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1784(T23_, 4));
}
LA17_: ;
}
break;
default:
{
arithAux__jsgen_1135(p, n, r, op);
}
break;
}
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, genReprAux__jsgen_4482)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* magic, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* typ) {
NimStringDesc* T1_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
useMagic__jsgen_779(p, magic);
T1_ = NIM_NIL;
T1_ = rawNewString((magic ? magic->Sup.len : 0) + 1);
appendString(T1_, magic);
appendString(T1_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_117));
add__ropes_162(&(*r).res, T1_);
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
{
if (!eqStrings(magic, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_283))) goto LA4_;
{
if (!(a.address == 0)) goto LA8_;
add__ropes_159(&(*r).res, a.res);
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_284));
}
goto LA6_;
LA8_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
nimZeroMem((void*)T11_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T11_[0] = a.address;
T11_[1] = a.res;
T12_ = NIM_NIL;
T12_ = percent___cgen_11991(T11_, 2);
add__ropes_159(&(*r).res, T12_);
}
LA6_: ;
}
goto LA2_;
LA4_: ;
{
add__ropes_159(&(*r).res, a.res);
}
LA2_: ;
{
if (!!((typ == 0))) goto LA16_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
add__ropes_159(&(*r).res, typ);
}
LA16_: ;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
}
N_LIB_PRIVATE N_NIMCALL(void, genRepr__jsgen_4500)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
t = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
switch ((*t).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 35):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_285), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_286), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_287), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 36) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 39):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_288), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_289), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 15):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
T7_ = NIM_NIL;
T7_ = genTypeInfo__jsgen_385(p, t);
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_290), T7_);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
T9_ = NIM_NIL;
T9_ = genTypeInfo__jsgen_385(p, t);
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_291), T9_);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 3):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 63):
{
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_292), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 0), TM__BxLwT0mhrtgTPodf1v3xjg_293, NIM_FALSE);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_294), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48):
{
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_295), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
break;
default:
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
T14_ = NIM_NIL;
T14_ = genTypeInfo__jsgen_385(p, t);
genReprAux__jsgen_4482(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_283), T14_);
}
break;
}
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2739)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_299), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2744)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_300), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genSwap__jsgen_2717)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w b;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&b), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&b));
tmp = getTemp__jsgen_838(p, NIM_FALSE);
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T3_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T4_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
T3_ = NIM_NIL;
T3_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
T4_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T4_ = mapType__jsgen_304(p, T3_);
if (!(T4_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA5_;
tmp2 = getTemp__jsgen_838(p, NIM_FALSE);
{
NIM_BOOL T9_;
T9_ = (NIM_BOOL)0;
T9_ = !((a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)));
if (T9_) goto LA10_;
T9_ = !((b.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)));
LA10_: ;
if (!T9_) goto LA11_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_297), TM__BxLwT0mhrtgTPodf1v3xjg_298);
}
LA11_: ;
nimZeroMem((void*)T13_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T13_[0] = tmp;
T13_[1] = a.address;
T13_[2] = b.address;
T14_ = NIM_NIL;
T14_ = percent___jsgen_2739(T13_, 3);
T15_ = NIM_NIL;
T15_ = indentLine__jsgen_97(p, T14_);
add__ropes_159(&(*p).body, T15_);
tmp = tmp2;
}
LA5_: ;
nimZeroMem((void*)T16_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T16_[0] = tmp;
T16_[1] = a.res;
T16_[2] = b.res;
T17_ = NIM_NIL;
T17_ = percent___jsgen_2744(T16_, 3);
T18_ = NIM_NIL;
T18_ = indentLine__jsgen_97(p, T17_);
add__ropes_159(&(*p).body, T18_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4625)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_302), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(NIM_BOOL, needsTemp__jsgen_951)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NIM_BOOL result;
{ result = (NIM_BOOL)0;
{
if (!((*n).kind >= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) && (*n).kind <= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32) || (*n).kind >= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 38) && (*n).kind <= ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 39) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 41) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 160))) goto LA3_;
result = NIM_TRUE;
goto BeforeRet_;
}
LA3_: ;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* c;
c = NIM_NIL;
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = safeLen__ast_3191(n);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA8;
i = i_2;
c = (*n)._kind_6.sons->data[i];
{
NIM_BOOL T11_;
T11_ = (NIM_BOOL)0;
T11_ = needsTemp__jsgen_951(p, c);
if (!T11_) goto LA12_;
result = NIM_TRUE;
goto BeforeRet_;
}
LA12_: ;
i_2 += ((NI) 1);
} LA8: ;
}
}
}
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_985)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_303), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_993)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_304), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, maybeMakeTemp__jsgen_964)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* x, tyTuple__nsNHL3sm0TZE9bootw2pEXw* Result) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b;
a = rdLoc__jsgen_188(x);
b = a;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = needsTemp__jsgen_951(p, n);
if (!T3_) goto LA4_;
{
NIM_BOOL T8_;
NIM_BOOL T10_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T11_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T15_;
T8_ = (NIM_BOOL)0;
T8_ = !(((*x).tmpLoc == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)));
if (!(T8_)) goto LA9_;
T10_ = (NIM_BOOL)0;
T11_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T11_ = mapType__jsgen_277((*n).typ);
T10_ = (T11_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
if (T10_) goto LA12_;
T10_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 65) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 47));
LA12_: ;
T8_ = T10_;
LA9_: ;
if (!T8_) goto LA13_;
nimZeroMem((void*)T15_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T15_[0] = (*x).tmpLoc;
b = percent___jsgen_985(T15_, 1);
unsureAsgnRef((void**) (&(*Result).Field0), a);
unsureAsgnRef((void**) (&(*Result).Field1), b);
}
goto LA6_;
LA13_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T17_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
b = tmp;
nimZeroMem((void*)T17_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_[0] = tmp;
T17_[1] = a;
a = percent___jsgen_993(T17_, 2);
unsureAsgnRef((void**) (&(*Result).Field0), a);
unsureAsgnRef((void**) (&(*Result).Field1), b);
}
LA6_: ;
}
goto LA1_;
LA4_: ;
{
unsureAsgnRef((void**) (&(*Result).Field0), a);
unsureAsgnRef((void**) (&(*Result).Field1), b);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4642)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_305), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4650)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_306), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4669)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_307), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4681)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_308), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4424)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_309), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4429)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_310), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4448)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_311), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4453)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_312), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4472)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_313), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4477)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_314), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genConStrStr__jsgen_4413)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
NI T25_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T3_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
T3_ = NIM_NIL;
T3_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T3_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2))) goto LA4_;
nimZeroMem((void*)T6_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T6_[0] = a.res;
T7_ = NIM_NIL;
T7_ = percent___jsgen_4424(T6_, 1);
add__ropes_159(&(*r).res, T7_);
}
goto LA1_;
LA4_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
nimZeroMem((void*)T9_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T9_[0] = a.res;
T10_ = NIM_NIL;
T10_ = percent___jsgen_4429(T9_, 1);
add__ropes_159(&(*r).res, T10_);
}
LA1_: ;
{
NI i;
NI colontmp_;
NI T12_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
T12_ = (NI)0;
T12_ = len__ast_3198(n);
colontmp_ = (NI)(T12_ - ((NI) 1));
i_2 = ((NI) 2);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA14;
i = i_2;
gen__jsgen_766(p, (*n)._kind_6.sons->data[i], (&a));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T17_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
T17_ = NIM_NIL;
T17_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[i]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T17_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2))) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T20_[0] = a.res;
T21_ = NIM_NIL;
T21_ = percent___jsgen_4448(T20_, 1);
add__ropes_159(&(*r).res, T21_);
}
goto LA15_;
LA18_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T23_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T24_;
nimZeroMem((void*)T23_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T23_[0] = a.res;
T24_ = NIM_NIL;
T24_ = percent___jsgen_4453(T23_, 1);
add__ropes_159(&(*r).res, T24_);
}
LA15_: ;
i_2 += ((NI) 1);
} LA14: ;
}
}
T25_ = (NI)0;
T25_ = len__ast_3198(n);
gen__jsgen_766(p, (*n)._kind_6.sons->data[(NI)(T25_ - ((NI) 1))], (&a));
{
NI T28_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T29_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T32_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T33_;
T28_ = (NI)0;
T28_ = len__ast_3198(n);
T29_ = NIM_NIL;
T29_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[(NI)(T28_ - ((NI) 1))]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T29_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2))) goto LA30_;
nimZeroMem((void*)T32_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T32_[0] = a.res;
T33_ = NIM_NIL;
T33_ = percent___jsgen_4472(T32_, 1);
add__ropes_159(&(*r).res, T33_);
}
goto LA26_;
LA30_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T35_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T36_;
nimZeroMem((void*)T35_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T35_[0] = a.res;
T36_ = NIM_NIL;
T36_ = percent___jsgen_4477(T35_, 1);
add__ropes_159(&(*r).res, T36_);
}
LA26_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4704)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_316), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4723)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_318), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4742)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_319), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4759)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_320), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4766)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_322), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1950)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_323), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4366)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_324), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4371)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_325), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genNew__jsgen_4346)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
t = (*T1_).sons->data[((NI) 0)];
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T4_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T7_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
T4_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T4_ = mapType__jsgen_277(t);
if (!(T4_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8))) goto LA5_;
nimZeroMem((void*)T7_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T7_[0] = rdLoc__jsgen_188((&a));
T7_[1] = createVar__jsgen_3791(p, t, NIM_FALSE);
T8_ = NIM_NIL;
T8_ = percent___jsgen_1950(T7_, 2);
T9_ = NIM_NIL;
T9_ = indentLine__jsgen_97(p, T8_);
add__ropes_159(&(*p).body, T9_);
}
goto LA2_;
LA5_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA11_;
nimZeroMem((void*)T13_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T13_[0] = a.address;
T13_[1] = a.res;
T13_[2] = createVar__jsgen_3791(p, t, NIM_FALSE);
T14_ = NIM_NIL;
T14_ = percent___jsgen_4366(T13_, 3);
T15_ = NIM_NIL;
T15_ = indentLine__jsgen_97(p, T14_);
add__ropes_159(&(*p).body, T15_);
}
goto LA2_;
LA11_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T19_;
nimZeroMem((void*)T17_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_[0] = rdLoc__jsgen_188((&a));
T17_[1] = createVar__jsgen_3791(p, t, NIM_FALSE);
T18_ = NIM_NIL;
T18_ = percent___jsgen_4371(T17_, 2);
T19_ = NIM_NIL;
T19_ = indentLine__jsgen_97(p, T18_);
add__ropes_159(&(*p).body, T19_);
}
LA2_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genJSArrayConstr__jsgen_4569)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_173)));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA6_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA6_: ;
gen__jsgen_766(p, (*n)._kind_6.sons->data[i], (&a));
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T13_;
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA10_;
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = a.address;
T12_[1] = a.res;
T13_ = NIM_NIL;
T13_ = percent___jsgen_462(T12_, 2);
add__ropes_159(&(*r).res, T13_);
}
goto LA8_;
LA10_: ;
{
{
NIM_BOOL T17_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T20_;
T17_ = (NIM_BOOL)0;
T17_ = needsNoCopy__jsgen_2483(p, (*n)._kind_6.sons->data[i]);
if (!!(T17_)) goto LA18_;
typ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[i]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T20_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T20_[0] = rdLoc__jsgen_188((&a));
T20_[1] = genTypeInfo__jsgen_385(p, typ);
a.res = percent___jsgen_4160(T20_, 2);
}
LA18_: ;
add__ropes_159(&(*r).res, a.res);
}
LA8_: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_174));
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4408)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_327), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genOrd__jsgen_4391)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_326);
switch ((*T1_).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 14):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31) ... ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 2):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym863_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym863_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym863_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym863_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T6_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw _;
T6_ = (NIM_BOOL)0;
T6_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_327), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T6_) goto LA7_;
nimZeroMem((void*)(&_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&_));
aX60gensym863_ = _.Field0;
tmpX60gensym863_ = _.Field1;
}
LA7_: ;
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = aX60gensym863_;
T9_[1] = tmpX60gensym863_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4408(T9_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_328), TM__BxLwT0mhrtgTPodf1v3xjg_329);
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4794)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_330), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4799)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_331), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4814)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_332), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4819)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_333), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1056)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_336), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1061)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_337), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1066)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_338), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, maybeMakeTempAssignable__jsgen_1002)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* x, tyTuple__nsNHL3sm0TZE9bootw2pEXw* Result) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b;
a = rdLoc__jsgen_188(x);
b = a;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = needsTemp__jsgen_951(p, n);
if (!T3_) goto LA4_;
{
NIM_BOOL T8_;
NIM_BOOL T10_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T11_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__2;
T8_ = (NIM_BOOL)0;
T8_ = !(((*x).tmpLoc == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)));
if (!(T8_)) goto LA9_;
T10_ = (NIM_BOOL)0;
T11_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T11_ = mapType__jsgen_277((*n).typ);
T10_ = (T11_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
if (T10_) goto LA12_;
T10_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 65) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 47));
LA12_: ;
T8_ = T10_;
LA9_: ;
if (!T8_) goto LA13_;
nimZeroMem((void*)T15_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T15_[0] = (*x).tmpLoc;
b = percent___jsgen_985(T15_, 1);
colontmp_ = a;
colontmp__2 = b;
unsureAsgnRef((void**) (&(*Result).Field0), colontmp_);
unsureAsgnRef((void**) (&(*Result).Field1), colontmp__2);
}
goto LA6_;
LA13_: ;
{
NIM_BOOL T17_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w address;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w index;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA first;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T21_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* m1;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp1;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T44_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* n1;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__3;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T45_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__4;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T46_;
T17_ = (NIM_BOOL)0;
T17_ = !(((*x).tmpLoc == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)));
if (!(T17_)) goto LA18_;
T17_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 42));
LA18_: ;
if (!T17_) goto LA19_;
nimZeroMem((void*)(&address), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&index), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&first), sizeof(tyObject_Int128__9a9axPfb75jdWY25AamJewkA));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&address));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&index));
nimZeroMem((void*)(&T21_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 0)], (&address), (&T21_));
m1 = NIM_NIL;
m1 = T21_.Field0;
tmp1 = NIM_NIL;
tmp1 = T21_.Field1;
typ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_334);
{
if (!((*typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16))) goto LA24_;
first = firstOrd__types_1353((*(*p).module).config, (*typ).sons->data[((NI) 0)]);
}
LA24_: ;
{
if (!(((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 4))&31U)))!=0)) goto LA28_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_335));
{
NIM_BOOL T32_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T35_;
T32_ = (NIM_BOOL)0;
T32_ = eqeq___int495056_759(first, IL64(0));
if (!T32_) goto LA33_;
nimZeroMem((void*)T35_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T35_[0] = index.res;
T35_[1] = tmp1;
index.res = percent___jsgen_1056(T35_, 2);
}
goto LA30_;
LA33_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T37_;
nimZeroMem((void*)T37_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T37_[0] = index.res;
T37_[1] = rope__jsgen_382(first);
T37_[2] = tmp1;
index.res = percent___jsgen_1061(T37_, 3);
}
LA30_: ;
}
goto LA26_;
LA28_: ;
{
NIM_BOOL T39_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T42_;
T39_ = (NIM_BOOL)0;
T39_ = eqeq___int495056_759(first, IL64(0));
if (!!(T39_)) goto LA40_;
nimZeroMem((void*)T42_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T42_[0] = index.res;
T42_[1] = rope__jsgen_382(first);
index.res = percent___jsgen_1066(T42_, 2);
}
goto LA26_;
LA40_: ;
{
}
LA26_: ;
nimZeroMem((void*)(&T44_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&index), (&T44_));
n1 = NIM_NIL;
n1 = T44_.Field0;
tmp2 = NIM_NIL;
tmp2 = T44_.Field1;
nimZeroMem((void*)T45_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T45_[0] = m1;
T45_[1] = n1;
colontmp__3 = percent___cgen_6775(T45_, 2);
nimZeroMem((void*)T46_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T46_[0] = tmp1;
T46_[1] = tmp2;
colontmp__4 = percent___cgen_6775(T46_, 2);
unsureAsgnRef((void**) (&(*Result).Field0), colontmp__3);
unsureAsgnRef((void**) (&(*Result).Field1), colontmp__4);
}
goto LA6_;
LA19_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__5;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__6;
colontmp__5 = a;
colontmp__6 = b;
unsureAsgnRef((void**) (&(*Result).Field0), colontmp__5);
unsureAsgnRef((void**) (&(*Result).Field1), colontmp__6);
}
LA6_: ;
}
goto LA1_;
LA4_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__7;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* colontmp__8;
colontmp__7 = a;
colontmp__8 = b;
unsureAsgnRef((void**) (&(*Result).Field0), colontmp__7);
unsureAsgnRef((void**) (&(*Result).Field1), colontmp__8);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4845)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_339), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, binaryUintExpr__jsgen_4829)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* op) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* trimmer;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T2_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__duFhZXIIlrbrM62cWjNekg T3_;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, abstractRange__types_101);
trimmer = unsignedTrimmerJS__jsgen_1101((*T1_).size);
nimZeroMem((void*)(&T2_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTempAssignable__jsgen_1002(p, (*n)._kind_6.sons->data[((NI) 1)], (&x), (&T2_));
a = NIM_NIL;
a = T2_.Field0;
tmp = NIM_NIL;
tmp = T2_.Field1;
nimZeroMem((void*)T3_, sizeof(tyArray__duFhZXIIlrbrM62cWjNekg));
T3_[0] = a;
T3_[1] = rope__ropes_109(op);
T3_[2] = rdLoc__jsgen_188((&y));
T3_[3] = trimmer;
T3_[4] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4845(T3_, 5));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4868)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_340), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4889)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_341), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4924)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_342), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4945)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_343), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4964)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_345), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4982)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_346), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4994)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_348), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5013)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_350), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5032)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_352), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5051)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_354), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5070)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_356), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5089)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_358), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5108)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_360), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5127)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_361), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5146)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_362), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5165)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_363), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4386)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_364), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genNewSeq__jsgen_4376)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T2_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T3_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T4_;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
t = (*T1_).sons->data[((NI) 0)];
nimZeroMem((void*)T2_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T2_[0] = rdLoc__jsgen_188((&x));
T2_[1] = rdLoc__jsgen_188((&y));
T2_[2] = createVar__jsgen_3791(p, t, NIM_FALSE);
T3_ = NIM_NIL;
T3_ = percent___jsgen_4386(T2_, 3);
T4_ = NIM_NIL;
T4_ = indentLine__jsgen_97(p, T3_);
add__ropes_159(&(*p).body, T4_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5177)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_184), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4522)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_366), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4527)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_368), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genOf__jsgen_4506)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
t = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 2)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_365);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T5_;
if (!(((*t).flags &((NU64)1<<((NU)(((tyEnum_TTypeFlag__x2m5g1NpbmDig4wLT3Ylhw) 2))&63U)))!=0)) goto LA3_;
nimZeroMem((void*)T5_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T5_[0] = x.res;
T5_[1] = genTypeInfo__jsgen_385(p, t);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4522(T5_, 2));
}
goto LA1_;
LA3_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T7_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_367));
nimZeroMem((void*)T7_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T7_[0] = x.res;
T7_[1] = genTypeInfo__jsgen_385(p, t);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4527(T7_, 2));
}
LA1_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, genDefault__jsgen_4532)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
unsureAsgnRef((void**) (&(*r).res), createVar__jsgen_3791(p, (*n).typ, NIM_FALSE));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4545)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_370), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_4554)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_371), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genReset__jsgen_4536)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_369));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T5_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
if (!(x.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA3_;
nimZeroMem((void*)T5_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T5_[0] = x.address;
T5_[1] = x.res;
T6_ = NIM_NIL;
T6_ = percent___jsgen_4545(T5_, 2);
T7_ = NIM_NIL;
T7_ = indentLine__jsgen_97(p, T6_);
add__ropes_159(&(*p).body, T7_);
}
goto LA1_;
LA3_: ;
{
tyTuple__nsNHL3sm0TZE9bootw2pEXw T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
nimZeroMem((void*)(&T9_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTempAssignable__jsgen_1002(p, (*n)._kind_6.sons->data[((NI) 1)], (&x), (&T9_));
a = NIM_NIL;
a = T9_.Field0;
tmp = NIM_NIL;
tmp = T9_.Field1;
nimZeroMem((void*)T10_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T10_[0] = a;
T10_[1] = genTypeInfo__jsgen_385(p, (*(*n)._kind_6.sons->data[((NI) 1)]).typ);
T10_[2] = tmp;
T11_ = NIM_NIL;
T11_ = percent___jsgen_4554(T10_, 3);
T12_ = NIM_NIL;
T12_ = indentLine__jsgen_97(p, T11_);
add__ropes_159(&(*p).body, T12_);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genArgNoParam__jsgen_3485)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, n, (&a));
{
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA3_;
add__ropes_159(&(*r).res, a.address);
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
add__ropes_159(&(*r).res, a.res);
}
goto LA1_;
LA3_: ;
{
add__ropes_159(&(*r).res, a.res);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genEcho__jsgen_3758)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n_2;
n_2 = skipConv__types_3597((*n)._kind_6.sons->data[((NI) 1)]);
{
NimStringDesc* argX60gensym758_;
if (!!(((*n_2).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 41)))) goto LA3_;
argX60gensym758_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_372);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym758_, TM__BxLwT0mhrtgTPodf1v3xjg_372);
}
LA3_: ;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_373));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_374));
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_375));
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n_2);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA7;
i = i_2;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
it = (*n_2)._kind_6.sons->data[i];
{
NIM_BOOL T11_;
T11_ = (NIM_BOOL)0;
T11_ = isCompileTimeOnly__types_3528((*it).typ);
if (!T11_) goto LA12_;
goto LA8;
}
LA12_: ;
{
if (!(((NI) 0) < i)) goto LA16_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA16_: ;
genArgNoParam__jsgen_3485(p, it, r);
} LA8: ;
i_2 += ((NI) 1);
} LA7: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5190)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_378), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5202)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_379), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3538)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_380), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genArg__jsgen_3494)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* param, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NI* emitted) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, n, (&a));
{
NIM_BOOL T3_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T4_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
T3_ = (NIM_BOOL)0;
T4_ = NIM_NIL;
T4_ = skipTypes__ast_3735((*param).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
T3_ = ((*T4_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27) || (*T4_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48));
if (!(T3_)) goto LA5_;
T3_ = (a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA5_: ;
if (!T3_) goto LA6_;
nimZeroMem((void*)T8_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T8_[0] = a.address;
T8_[1] = a.res;
T9_ = NIM_NIL;
T9_ = percent___cgen_6775(T8_, 2);
add__ropes_159(&(*r).res, T9_);
}
goto LA1_;
LA6_: ;
{
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA11_;
add__ropes_159(&(*r).res, a.address);
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
add__ropes_159(&(*r).res, a.res);
{
if (!!((emitted == ((NI*) NIM_NIL)))) goto LA15_;
(*emitted) += ((NI) 1);
}
LA15_: ;
}
goto LA1_;
LA11_: ;
{
NIM_BOOL T18_;
NIM_BOOL T19_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T25_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T26_;
T18_ = (NIM_BOOL)0;
T19_ = (NIM_BOOL)0;
T19_ = ((*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23) || (*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21) || (*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22) || (*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47) || (*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45));
if (!(T19_)) goto LA20_;
T19_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 27) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 29) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 30) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 31) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 28) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32));
LA20_: ;
T18_ = T19_;
if (!(T18_)) goto LA21_;
T22_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T22_ = mapType__jsgen_277((*param).typ);
T18_ = (T22_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA21_: ;
if (!T18_) goto LA23_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T25_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T25_[0] = tmp;
T25_[1] = rdLoc__jsgen_188((&a));
T26_ = NIM_NIL;
T26_ = percent___jsgen_3538(T25_, 2);
add__ropes_159(&(*r).res, T26_);
{
if (!!((emitted == ((NI*) NIM_NIL)))) goto LA29_;
(*emitted) += ((NI) 1);
}
LA29_: ;
}
goto LA1_;
LA23_: ;
{
add__ropes_159(&(*r).res, a.res);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genArgs__jsgen_3551)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NI start) {
NIM_BOOL hasArgs;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
NI emitted;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_117));
hasArgs = NIM_FALSE;
typ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
emitted = (NI)(start - ((NI) 1));
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = start;
{
while (1) {
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* paramType;
it = (*n)._kind_6.sons->data[i];
paramType = ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL);
{
NI T7_;
T7_ = (NI)0;
T7_ = len__ast_4002(typ);
if (!(i < T7_)) goto LA8_;
paramType = (*(*typ).n)._kind_6.sons->data[i];
{
NIM_BOOL T12_;
T12_ = (NIM_BOOL)0;
T12_ = isCompileTimeOnly__types_3528((*paramType).typ);
if (!T12_) goto LA13_;
goto LA4;
}
LA13_: ;
}
LA8_: ;
{
if (!hasArgs) goto LA17_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA17_: ;
{
if (!(paramType == 0)) goto LA21_;
genArgNoParam__jsgen_3485(p, it, r);
}
goto LA19_;
LA21_: ;
{
genArg__jsgen_3494(p, it, (*paramType)._kind_4.sym, r, (&emitted));
}
LA19_: ;
emitted += ((NI) 1);
hasArgs = NIM_TRUE;
} LA4: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2817)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_381), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genCall__jsgen_3735)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
genArgs__jsgen_3551(p, n, r, ((NI) 1));
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA t;
if (!!(((*n).typ == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)))) goto LA3_;
t = mapType__jsgen_277((*n).typ);
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
if (!(t == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA7_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = tmp;
T9_[1] = rdLoc__jsgen_188((&(*r)));
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2817(T9_, 2));
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T10_, 1));
unsureAsgnRef((void**) (&(*r).tmpLoc), tmp);
(*r).typ = t;
}
LA7_: ;
}
LA3_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5214)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_383), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genMove__jsgen_4559)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T1_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T2_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T3_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
nimZeroMem((void*)T1_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T1_[0] = rdLoc__jsgen_188((&(*r)));
T1_[1] = rdLoc__jsgen_188((&a));
T2_ = NIM_NIL;
T2_ = percent___jsgen_1950(T1_, 2);
T3_ = NIM_NIL;
T3_ = indentLine__jsgen_97(p, T2_);
add__ropes_159(&(*p).body, T3_);
genReset__jsgen_4536(p, n);
}
N_LIB_PRIVATE N_NIMCALL(void, genMagic__jsgen_4598)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* line;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* filen;
tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg op;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
line = NIM_NIL;
filen = NIM_NIL;
op = (*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).magic;
switch (op) {
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 110):
{
genOr__jsgen_903(p, (*n)._kind_6.sons->data[((NI) 1)], (*n)._kind_6.sons->data[((NI) 2)], r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 109):
{
genAnd__jsgen_856(p, (*n)._kind_6.sons->data[((NI) 1)], (*n)._kind_6.sons->data[((NI) 2)], r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 46) ... ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 107):
{
arith__jsgen_1716(p, n, r, op);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 135):
{
genRepr__jsgen_4500(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 142):
{
genSwap__jsgen_2717(p, n);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 131):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym905_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym905_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym905_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym905_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym905_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym905_;
tyArray__f7nG5LD47BH5K9c6mASit3g T7_;
nimZeroMem((void*)(&xX60gensym905_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym905_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_301));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym905_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym905_));
aX60gensym905_ = rdLoc__jsgen_188((&xX60gensym905_));
tmpX60gensym905_ = rdLoc__jsgen_188((&xX60gensym905_));
bX60gensym905_ = rdLoc__jsgen_188((&yX60gensym905_));
tmp2X60gensym905_ = rdLoc__jsgen_188((&yX60gensym905_));
nimZeroMem((void*)T7_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T7_[0] = aX60gensym905_;
T7_[1] = bX60gensym905_;
T7_[2] = tmpX60gensym905_;
T7_[3] = tmp2X60gensym905_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4625(T7_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 132):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w lhs;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w rhs;
nimZeroMem((void*)(&lhs), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&rhs), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&lhs));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&rhs));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T11_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T15_;
T11_ = NIM_NIL;
T11_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T11_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29))) goto LA12_;
nimZeroMem((void*)(&T14_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 2)], (&rhs), (&T14_));
b = NIM_NIL;
b = T14_.Field0;
tmp = NIM_NIL;
tmp = T14_.Field1;
nimZeroMem((void*)T15_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T15_[0] = b;
T15_[1] = rdLoc__jsgen_188((&lhs));
T15_[2] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4642(T15_, 3));
}
goto LA9_;
LA12_: ;
{
tyTuple__nsNHL3sm0TZE9bootw2pEXw T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a_2;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp_2;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T18_;
nimZeroMem((void*)(&T17_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&lhs), (&T17_));
a_2 = NIM_NIL;
a_2 = T17_.Field0;
tmp_2 = NIM_NIL;
tmp_2 = T17_.Field1;
nimZeroMem((void*)T18_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T18_[0] = a_2;
T18_[1] = rdLoc__jsgen_188((&rhs));
T18_[2] = tmp_2;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4650(T18_, 3));
}
LA9_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 133):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y;
nimZeroMem((void*)(&x), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y));
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* c;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T25_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T26_;
T22_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T22_ = mapType__jsgen_277((*(*n)._kind_6.sons->data[((NI) 2)]).typ);
if (!(T22_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA23_;
nimZeroMem((void*)T25_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T25_[0] = y.address;
T25_[1] = y.res;
c = percent___jsgen_462(T25_, 2);
nimZeroMem((void*)T26_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T26_[0] = rdLoc__jsgen_188((&x));
T26_[1] = c;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4669(T26_, 2));
}
goto LA20_;
LA23_: ;
{
NIM_BOOL T28_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T31_;
T28_ = (NIM_BOOL)0;
T28_ = needsNoCopy__jsgen_2483(p, (*n)._kind_6.sons->data[((NI) 2)]);
if (!T28_) goto LA29_;
nimZeroMem((void*)T31_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T31_[0] = rdLoc__jsgen_188((&x));
T31_[1] = rdLoc__jsgen_188((&y));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4669(T31_, 2));
}
goto LA20_;
LA29_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* c_2;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T33_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T34_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T35_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T36_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
c_2 = getTemp__jsgen_838(p, NIM_FALSE);
nimZeroMem((void*)T33_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T33_[0] = c_2;
T33_[1] = rdLoc__jsgen_188((&y));
T33_[2] = genTypeInfo__jsgen_385(p, (*(*n)._kind_6.sons->data[((NI) 2)]).typ);
T34_ = NIM_NIL;
T34_ = percent___jsgen_4681(T33_, 3);
T35_ = NIM_NIL;
T35_ = indentLine__jsgen_97(p, T34_);
add__ropes_159(&(*p).body, T35_);
nimZeroMem((void*)T36_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T36_[0] = rdLoc__jsgen_188((&x));
T36_[1] = c_2;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4669(T36_, 2));
}
LA20_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 125):
{
genConStrStr__jsgen_4413(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 116):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym921_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym921_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym921_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym921_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym921_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym921_;
tyArray__f7nG5LD47BH5K9c6mASit3g T39_;
nimZeroMem((void*)(&xX60gensym921_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym921_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_315));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym921_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym921_));
aX60gensym921_ = rdLoc__jsgen_188((&xX60gensym921_));
tmpX60gensym921_ = rdLoc__jsgen_188((&xX60gensym921_));
bX60gensym921_ = rdLoc__jsgen_188((&yX60gensym921_));
tmp2X60gensym921_ = rdLoc__jsgen_188((&yX60gensym921_));
nimZeroMem((void*)T39_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T39_[0] = aX60gensym921_;
T39_[1] = bX60gensym921_;
T39_[2] = tmpX60gensym921_;
T39_[3] = tmp2X60gensym921_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4704(T39_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 117):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym926_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym926_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym926_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym926_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym926_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym926_;
tyArray__f7nG5LD47BH5K9c6mASit3g T41_;
nimZeroMem((void*)(&xX60gensym926_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym926_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_317));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym926_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym926_));
aX60gensym926_ = rdLoc__jsgen_188((&xX60gensym926_));
tmpX60gensym926_ = rdLoc__jsgen_188((&xX60gensym926_));
bX60gensym926_ = rdLoc__jsgen_188((&yX60gensym926_));
tmp2X60gensym926_ = rdLoc__jsgen_188((&yX60gensym926_));
nimZeroMem((void*)T41_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T41_[0] = aX60gensym926_;
T41_[1] = bX60gensym926_;
T41_[2] = tmpX60gensym926_;
T41_[3] = tmp2X60gensym926_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4723(T41_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 118):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym931_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym931_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym931_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym931_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym931_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym931_;
tyArray__f7nG5LD47BH5K9c6mASit3g T43_;
nimZeroMem((void*)(&xX60gensym931_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym931_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_317));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym931_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym931_));
aX60gensym931_ = rdLoc__jsgen_188((&xX60gensym931_));
tmpX60gensym931_ = rdLoc__jsgen_188((&xX60gensym931_));
bX60gensym931_ = rdLoc__jsgen_188((&yX60gensym931_));
tmp2X60gensym931_ = rdLoc__jsgen_188((&yX60gensym931_));
nimZeroMem((void*)T43_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T43_[0] = aX60gensym931_;
T43_[1] = bX60gensym931_;
T43_[2] = tmpX60gensym931_;
T43_[3] = tmp2X60gensym931_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4742(T43_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 143):
{
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T47_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym938_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym938_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T55_;
T47_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T47_ = mapType__jsgen_277((*(*n)._kind_6.sons->data[((NI) 1)]).typ);
if (!!((T47_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)))) goto LA48_;
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym938_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym938_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T52_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw _;
T52_ = (NIM_BOOL)0;
T52_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_320), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T52_) goto LA53_;
nimZeroMem((void*)(&_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&_));
aX60gensym938_ = _.Field0;
tmpX60gensym938_ = _.Field1;
}
LA53_: ;
nimZeroMem((void*)T55_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T55_[0] = aX60gensym938_;
T55_[1] = tmpX60gensym938_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4759(T55_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
goto LA45_;
LA48_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_2;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T57_;
nimZeroMem((void*)(&x_2), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_2));
nimZeroMem((void*)T57_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T57_[0] = x_2.address;
T57_[1] = x_2.res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4766(T57_, 2));
}
LA45_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 108):
{
genRepr__jsgen_4500(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 32):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 33):
{
genNew__jsgen_4346(p, n);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 43):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 144):
{
{
if (!((*(*n)._kind_6.sons->data[((NI) 1)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 41))) goto LA64_;
genJSArrayConstr__jsgen_4569(p, (*n)._kind_6.sons->data[((NI) 1)], r);
}
goto LA62_;
LA64_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_3;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T67_;
nimZeroMem((void*)(&x_3), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_3));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T67_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T67_[0] = rdLoc__jsgen_188((&x_3));
T67_[1] = genTypeInfo__jsgen_385(p, (*n).typ);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4160(T67_, 2));
}
LA62_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 150):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 151):
{
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 31):
{
genOrd__jsgen_4391(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 37):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 39):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 36):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 38):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_4;
nimZeroMem((void*)(&x_4), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_4));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T73_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T76_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a_3;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp_3;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T77_;
T73_ = NIM_NIL;
T73_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
if (!((*T73_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29))) goto LA74_;
nimZeroMem((void*)(&T76_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_4), (&T76_));
a_3 = NIM_NIL;
a_3 = T76_.Field0;
tmp_3 = NIM_NIL;
tmp_3 = T76_.Field1;
nimZeroMem((void*)T77_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T77_[0] = a_3;
T77_[1] = tmp_3;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4794(T77_, 2));
}
goto LA71_;
LA74_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T79_;
nimZeroMem((void*)T79_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T79_[0] = rdLoc__jsgen_188((&x_4));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4799(T79_, 1));
}
LA71_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 9):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_5;
nimZeroMem((void*)(&x_5), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_5));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T83_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T86_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a_4;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp_4;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T87_;
T83_ = NIM_NIL;
T83_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
if (!((*T83_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29))) goto LA84_;
nimZeroMem((void*)(&T86_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_5), (&T86_));
a_4 = NIM_NIL;
a_4 = T86_.Field0;
tmp_4 = NIM_NIL;
tmp_4 = T86_.Field1;
nimZeroMem((void*)T87_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T87_[0] = a_4;
T87_[1] = tmp_4;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4814(T87_, 2));
}
goto LA81_;
LA84_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T89_;
nimZeroMem((void*)T89_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T89_[0] = rdLoc__jsgen_188((&x_5));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4819(T89_, 1));
}
LA81_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 29):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T93_;
T93_ = NIM_NIL;
T93_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_235);
if (!((*T93_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) && (*T93_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44))) goto LA94_;
binaryUintExpr__jsgen_4829(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_231));
}
goto LA91_;
LA94_: ;
{
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym961_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym961_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym961_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym961_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym961_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym961_;
tyArray__f7nG5LD47BH5K9c6mASit3g T101_;
if (!!((((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 5))&31U)))!=0))) goto LA99_;
nimZeroMem((void*)(&xX60gensym961_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym961_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym961_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym961_));
aX60gensym961_ = rdLoc__jsgen_188((&xX60gensym961_));
tmpX60gensym961_ = rdLoc__jsgen_188((&xX60gensym961_));
bX60gensym961_ = rdLoc__jsgen_188((&yX60gensym961_));
tmp2X60gensym961_ = rdLoc__jsgen_188((&yX60gensym961_));
nimZeroMem((void*)T101_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T101_[0] = aX60gensym961_;
T101_[1] = bX60gensym961_;
T101_[2] = tmpX60gensym961_;
T101_[3] = tmp2X60gensym961_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4868(T101_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
goto LA97_;
LA99_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym966_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym966_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym966_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym966_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym966_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym966_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __2;
tyArray__f7nG5LD47BH5K9c6mASit3g T103_;
nimZeroMem((void*)(&xX60gensym966_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym966_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_237));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym966_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym966_));
aX60gensym966_ = rdLoc__jsgen_188((&xX60gensym966_));
tmpX60gensym966_ = rdLoc__jsgen_188((&xX60gensym966_));
bX60gensym966_ = rdLoc__jsgen_188((&yX60gensym966_));
tmp2X60gensym966_ = rdLoc__jsgen_188((&yX60gensym966_));
nimZeroMem((void*)(&__2), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTempAssignable__jsgen_1002(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym966_), (&__2));
aX60gensym966_ = __2.Field0;
tmpX60gensym966_ = __2.Field1;
nimZeroMem((void*)T103_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T103_[0] = aX60gensym966_;
T103_[1] = bX60gensym966_;
T103_[2] = tmpX60gensym966_;
T103_[3] = tmp2X60gensym966_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4889(T103_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA97_: ;
}
LA91_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 30):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T107_;
T107_ = NIM_NIL;
T107_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_235);
if (!((*T107_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) && (*T107_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44))) goto LA108_;
binaryUintExpr__jsgen_4829(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_232));
}
goto LA105_;
LA108_: ;
{
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym973_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym973_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym973_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym973_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym973_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym973_;
tyArray__f7nG5LD47BH5K9c6mASit3g T115_;
if (!!((((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 5))&31U)))!=0))) goto LA113_;
nimZeroMem((void*)(&xX60gensym973_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym973_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym973_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym973_));
aX60gensym973_ = rdLoc__jsgen_188((&xX60gensym973_));
tmpX60gensym973_ = rdLoc__jsgen_188((&xX60gensym973_));
bX60gensym973_ = rdLoc__jsgen_188((&yX60gensym973_));
tmp2X60gensym973_ = rdLoc__jsgen_188((&yX60gensym973_));
nimZeroMem((void*)T115_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T115_[0] = aX60gensym973_;
T115_[1] = bX60gensym973_;
T115_[2] = tmpX60gensym973_;
T115_[3] = tmp2X60gensym973_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4924(T115_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
goto LA111_;
LA113_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym978_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym978_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym978_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym978_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym978_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym978_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __3;
tyArray__f7nG5LD47BH5K9c6mASit3g T117_;
nimZeroMem((void*)(&xX60gensym978_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym978_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_238));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym978_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym978_));
aX60gensym978_ = rdLoc__jsgen_188((&xX60gensym978_));
tmpX60gensym978_ = rdLoc__jsgen_188((&xX60gensym978_));
bX60gensym978_ = rdLoc__jsgen_188((&yX60gensym978_));
tmp2X60gensym978_ = rdLoc__jsgen_188((&yX60gensym978_));
nimZeroMem((void*)(&__3), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTempAssignable__jsgen_1002(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym978_), (&__3));
aX60gensym978_ = __3.Field0;
tmpX60gensym978_ = __3.Field1;
nimZeroMem((void*)T117_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T117_[0] = aX60gensym978_;
T117_[1] = bX60gensym978_;
T117_[2] = tmpX60gensym978_;
T117_[3] = tmp2X60gensym978_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4945(T117_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA111_: ;
}
LA105_: ;
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 137):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym982_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym982_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym982_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym982_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym982_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym982_;
tyArray__f7nG5LD47BH5K9c6mASit3g T119_;
nimZeroMem((void*)(&xX60gensym982_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym982_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_344));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym982_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym982_));
aX60gensym982_ = rdLoc__jsgen_188((&xX60gensym982_));
tmpX60gensym982_ = rdLoc__jsgen_188((&xX60gensym982_));
bX60gensym982_ = rdLoc__jsgen_188((&yX60gensym982_));
tmp2X60gensym982_ = rdLoc__jsgen_188((&yX60gensym982_));
nimZeroMem((void*)T119_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T119_[0] = aX60gensym982_;
T119_[1] = bX60gensym982_;
T119_[2] = tmpX60gensym982_;
T119_[3] = tmp2X60gensym982_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4964(T119_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 138):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_6;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y_2;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T121_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T122_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* a_5;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp_5;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T123_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* b_2;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2;
tyArray__duFhZXIIlrbrM62cWjNekg T124_;
nimZeroMem((void*)(&x_6), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y_2), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_6));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y_2));
T121_ = NIM_NIL;
T121_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
t = (*T121_).sons->data[((NI) 0)];
nimZeroMem((void*)(&T122_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_6), (&T122_));
a_5 = NIM_NIL;
a_5 = T122_.Field0;
tmp_5 = NIM_NIL;
tmp_5 = T122_.Field1;
nimZeroMem((void*)(&T123_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 2)], (&y_2), (&T123_));
b_2 = NIM_NIL;
b_2 = T123_.Field0;
tmp2 = NIM_NIL;
tmp2 = T123_.Field1;
nimZeroMem((void*)T124_, sizeof(tyArray__duFhZXIIlrbrM62cWjNekg));
T124_[0] = a_5;
T124_[1] = b_2;
T124_[2] = createVar__jsgen_3791(p, t, NIM_FALSE);
T124_[3] = tmp_5;
T124_[4] = tmp2;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4982(T124_, 5));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 42):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym993_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym993_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T131_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_347));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym993_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym993_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T128_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __4;
T128_ = (NIM_BOOL)0;
T128_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_348), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T128_) goto LA129_;
nimZeroMem((void*)(&__4), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&__4));
aX60gensym993_ = __4.Field0;
tmpX60gensym993_ = __4.Field1;
}
LA129_: ;
nimZeroMem((void*)T131_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T131_[0] = aX60gensym993_;
T131_[1] = tmpX60gensym993_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_4994(T131_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 121):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym997_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym997_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym997_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym997_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym997_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym997_;
tyArray__f7nG5LD47BH5K9c6mASit3g T133_;
nimZeroMem((void*)(&xX60gensym997_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym997_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_349));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym997_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym997_));
aX60gensym997_ = rdLoc__jsgen_188((&xX60gensym997_));
tmpX60gensym997_ = rdLoc__jsgen_188((&xX60gensym997_));
bX60gensym997_ = rdLoc__jsgen_188((&yX60gensym997_));
tmp2X60gensym997_ = rdLoc__jsgen_188((&yX60gensym997_));
nimZeroMem((void*)T133_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T133_[0] = aX60gensym997_;
T133_[1] = bX60gensym997_;
T133_[2] = tmpX60gensym997_;
T133_[3] = tmp2X60gensym997_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5013(T133_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 120):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1002_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1002_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1002_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1002_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1002_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1002_;
tyArray__f7nG5LD47BH5K9c6mASit3g T135_;
nimZeroMem((void*)(&xX60gensym1002_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1002_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_351));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1002_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1002_));
aX60gensym1002_ = rdLoc__jsgen_188((&xX60gensym1002_));
tmpX60gensym1002_ = rdLoc__jsgen_188((&xX60gensym1002_));
bX60gensym1002_ = rdLoc__jsgen_188((&yX60gensym1002_));
tmp2X60gensym1002_ = rdLoc__jsgen_188((&yX60gensym1002_));
nimZeroMem((void*)T135_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T135_[0] = aX60gensym1002_;
T135_[1] = bX60gensym1002_;
T135_[2] = tmpX60gensym1002_;
T135_[3] = tmp2X60gensym1002_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5032(T135_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 119):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1007_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1007_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1007_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1007_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1007_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1007_;
tyArray__f7nG5LD47BH5K9c6mASit3g T137_;
nimZeroMem((void*)(&xX60gensym1007_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1007_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_353));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1007_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1007_));
aX60gensym1007_ = rdLoc__jsgen_188((&xX60gensym1007_));
tmpX60gensym1007_ = rdLoc__jsgen_188((&xX60gensym1007_));
bX60gensym1007_ = rdLoc__jsgen_188((&yX60gensym1007_));
tmp2X60gensym1007_ = rdLoc__jsgen_188((&yX60gensym1007_));
nimZeroMem((void*)T137_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T137_[0] = aX60gensym1007_;
T137_[1] = bX60gensym1007_;
T137_[2] = tmpX60gensym1007_;
T137_[3] = tmp2X60gensym1007_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5051(T137_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 122):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1012_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1012_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1012_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1012_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1012_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1012_;
tyArray__f7nG5LD47BH5K9c6mASit3g T139_;
nimZeroMem((void*)(&xX60gensym1012_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1012_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_355));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1012_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1012_));
aX60gensym1012_ = rdLoc__jsgen_188((&xX60gensym1012_));
tmpX60gensym1012_ = rdLoc__jsgen_188((&xX60gensym1012_));
bX60gensym1012_ = rdLoc__jsgen_188((&yX60gensym1012_));
tmp2X60gensym1012_ = rdLoc__jsgen_188((&yX60gensym1012_));
nimZeroMem((void*)T139_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T139_[0] = aX60gensym1012_;
T139_[1] = bX60gensym1012_;
T139_[2] = tmpX60gensym1012_;
T139_[3] = tmp2X60gensym1012_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5070(T139_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 123):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1017_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1017_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1017_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1017_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1017_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1017_;
tyArray__f7nG5LD47BH5K9c6mASit3g T141_;
nimZeroMem((void*)(&xX60gensym1017_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1017_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_357));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1017_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1017_));
aX60gensym1017_ = rdLoc__jsgen_188((&xX60gensym1017_));
tmpX60gensym1017_ = rdLoc__jsgen_188((&xX60gensym1017_));
bX60gensym1017_ = rdLoc__jsgen_188((&yX60gensym1017_));
tmp2X60gensym1017_ = rdLoc__jsgen_188((&yX60gensym1017_));
nimZeroMem((void*)T141_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T141_[0] = aX60gensym1017_;
T141_[1] = bX60gensym1017_;
T141_[2] = tmpX60gensym1017_;
T141_[3] = tmp2X60gensym1017_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5089(T141_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 124):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1022_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1022_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1022_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1022_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1022_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1022_;
tyArray__f7nG5LD47BH5K9c6mASit3g T143_;
nimZeroMem((void*)(&xX60gensym1022_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1022_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_359));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1022_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1022_));
aX60gensym1022_ = rdLoc__jsgen_188((&xX60gensym1022_));
tmpX60gensym1022_ = rdLoc__jsgen_188((&xX60gensym1022_));
bX60gensym1022_ = rdLoc__jsgen_188((&yX60gensym1022_));
tmp2X60gensym1022_ = rdLoc__jsgen_188((&yX60gensym1022_));
nimZeroMem((void*)T143_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T143_[0] = aX60gensym1022_;
T143_[1] = bX60gensym1022_;
T143_[2] = tmpX60gensym1022_;
T143_[3] = tmp2X60gensym1022_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5108(T143_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 40):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1027_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1027_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1027_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1027_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1027_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1027_;
tyArray__f7nG5LD47BH5K9c6mASit3g T145_;
nimZeroMem((void*)(&xX60gensym1027_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1027_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1027_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1027_));
aX60gensym1027_ = rdLoc__jsgen_188((&xX60gensym1027_));
tmpX60gensym1027_ = rdLoc__jsgen_188((&xX60gensym1027_));
bX60gensym1027_ = rdLoc__jsgen_188((&yX60gensym1027_));
tmp2X60gensym1027_ = rdLoc__jsgen_188((&yX60gensym1027_));
nimZeroMem((void*)T145_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T145_[0] = aX60gensym1027_;
T145_[1] = bX60gensym1027_;
T145_[2] = tmpX60gensym1027_;
T145_[3] = tmp2X60gensym1027_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5127(T145_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 41):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1032_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1032_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1032_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1032_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1032_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1032_;
tyArray__f7nG5LD47BH5K9c6mASit3g T147_;
nimZeroMem((void*)(&xX60gensym1032_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1032_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1032_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1032_));
aX60gensym1032_ = rdLoc__jsgen_188((&xX60gensym1032_));
tmpX60gensym1032_ = rdLoc__jsgen_188((&xX60gensym1032_));
bX60gensym1032_ = rdLoc__jsgen_188((&yX60gensym1032_));
tmp2X60gensym1032_ = rdLoc__jsgen_188((&yX60gensym1032_));
nimZeroMem((void*)T147_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T147_[0] = aX60gensym1032_;
T147_[1] = bX60gensym1032_;
T147_[2] = tmpX60gensym1032_;
T147_[3] = tmp2X60gensym1032_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5146(T147_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 134):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w xX60gensym1037_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w yX60gensym1037_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1037_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1037_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* bX60gensym1037_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp2X60gensym1037_;
tyArray__f7nG5LD47BH5K9c6mASit3g T149_;
nimZeroMem((void*)(&xX60gensym1037_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&yX60gensym1037_), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&xX60gensym1037_));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&yX60gensym1037_));
aX60gensym1037_ = rdLoc__jsgen_188((&xX60gensym1037_));
tmpX60gensym1037_ = rdLoc__jsgen_188((&xX60gensym1037_));
bX60gensym1037_ = rdLoc__jsgen_188((&yX60gensym1037_));
tmp2X60gensym1037_ = rdLoc__jsgen_188((&yX60gensym1037_));
nimZeroMem((void*)T149_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T149_[0] = aX60gensym1037_;
T149_[1] = bX60gensym1037_;
T149_[2] = tmpX60gensym1037_;
T149_[3] = tmp2X60gensym1037_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5165(T149_, 4));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 34):
{
genNewSeq__jsgen_4376(p, n);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 35):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1042_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1042_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T157_;
useMagic__jsgen_779(p, ((NimStringDesc*) NIM_NIL));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym1042_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym1042_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T154_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __5;
T154_ = (NIM_BOOL)0;
T154_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_184), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T154_) goto LA155_;
nimZeroMem((void*)(&__5), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&__5));
aX60gensym1042_ = __5.Field0;
tmpX60gensym1042_ = __5.Field1;
}
LA155_: ;
nimZeroMem((void*)T157_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T157_[0] = aX60gensym1042_;
T157_[1] = tmpX60gensym1042_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5177(T157_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 15):
{
genOf__jsgen_4506(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 152):
{
genDefault__jsgen_4532(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 158):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 149):
{
genReset__jsgen_4536(p, n);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 20):
{
genEcho__jsgen_3758(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 212) ... ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 259):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 22):
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 23):
{
NimStringDesc* T163_;
T163_ = NIM_NIL;
T163_ = nsuFormatSingleElem(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_376), (*(*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).name).s);
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), T163_, ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 0), TM__BxLwT0mhrtgTPodf1v3xjg_377, NIM_FALSE);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 145):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1050_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1050_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T170_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_344));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym1050_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym1050_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T167_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __6;
T167_ = (NIM_BOOL)0;
T167_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_378), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T167_) goto LA168_;
nimZeroMem((void*)(&__6), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&__6));
aX60gensym1050_ = __6.Field0;
tmpX60gensym1050_ = __6.Field1;
}
LA168_: ;
nimZeroMem((void*)T170_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T170_[0] = aX60gensym1050_;
T170_[1] = tmpX60gensym1050_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5190(T170_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 146):
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* aX60gensym1054_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym1054_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T177_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_344));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
aX60gensym1054_ = rdLoc__jsgen_188((&(*r)));
tmpX60gensym1054_ = rdLoc__jsgen_188((&(*r)));
{
NIM_BOOL T174_;
tyTuple__nsNHL3sm0TZE9bootw2pEXw __7;
T174_ = (NIM_BOOL)0;
T174_ = contains__pureZstrutils_1631(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_379), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_321));
if (!T174_) goto LA175_;
nimZeroMem((void*)(&__7), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*n)._kind_6.sons->data[((NI) 1)], (&(*r)), (&__7));
aX60gensym1054_ = __7.Field0;
tmpX60gensym1054_ = __7.Field1;
}
LA175_: ;
nimZeroMem((void*)T177_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T177_[0] = aX60gensym1054_;
T177_[1] = tmpX60gensym1054_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5202(T177_, 2));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 127):
{
genProcForSymIfNeeded__jsgen_3222(p, (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym);
genCall__jsgen_3735(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 147):
{
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_382));
genCall__jsgen_3735(p, n, r);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 126):
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w x_7;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w y_3;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w z;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T181_;
nimZeroMem((void*)(&x_7), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&y_3), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&z), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&x_7));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&y_3));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 3)], (&z));
nimZeroMem((void*)T181_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T181_[0] = rdLoc__jsgen_188((&x_7));
T181_[1] = rdLoc__jsgen_188((&y_3));
T181_[2] = rdLoc__jsgen_188((&z));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5214(T181_, 3));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 148):
{
genMove__jsgen_4559(p, n, r);
}
break;
default:
{
genCall__jsgen_3735(p, n, r);
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(void, genOtherArg__jsgen_3606)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, NI i, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, NI* generated, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* paramType;
{ {
NI T3_;
NimStringDesc* T6_;
NimStringDesc* T7_;
NI T8_;
NimStringDesc* T9_;
T3_ = (NI)0;
T3_ = len__ast_3198(n);
if (!(T3_ <= i)) goto LA4_;
T6_ = NIM_NIL;
T7_ = NIM_NIL;
T7_ = dollar___systemZdollars_3(i);
T8_ = (NI)0;
T8_ = len__ast_3198(n);
T9_ = NIM_NIL;
T9_ = dollar___systemZdollars_3((NI)(T8_ - ((NI) 1)));
T6_ = rawNewString((T7_ ? T7_->Sup.len : 0) + (T9_ ? T9_->Sup.len : 0) + 71);
appendString(T6_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_386));
appendString(T6_, T7_);
appendString(T6_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_387));
appendString(T6_, T9_);
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), T6_, ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 2), TM__BxLwT0mhrtgTPodf1v3xjg_388, NIM_FALSE);
}
LA4_: ;
it = (*n)._kind_6.sons->data[i];
paramType = ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL);
{
NI T12_;
T12_ = (NI)0;
T12_ = len__ast_4002(typ);
if (!(i < T12_)) goto LA13_;
paramType = (*(*typ).n)._kind_6.sons->data[i];
{
NIM_BOOL T17_;
T17_ = (NIM_BOOL)0;
T17_ = isCompileTimeOnly__types_3528((*paramType).typ);
if (!T17_) goto LA18_;
goto BeforeRet_;
}
LA18_: ;
}
LA13_: ;
{
if (!(paramType == 0)) goto LA22_;
genArgNoParam__jsgen_3485(p, it, r);
}
goto LA20_;
LA22_: ;
{
genArg__jsgen_3494(p, it, (*paramType)._kind_4.sym, r, ((NI*) NIM_NIL));
}
LA20_: ;
(*generated) += ((NI) 1);
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genPatternCall__jsgen_3641)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, NimStringDesc* pat, tyObject_TType__facALICuu8zUj0hjvbTLFg* typ, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
NI i;
NI j;
i = ((NI) 0);
j = ((NI) 1);
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
while (1) {
if (!(i < (pat ? pat->Sup.len : 0))) goto LA2;
switch (((NU8)(pat->data[i]))) {
case 64:
{
NI generated;
generated = ((NI) 0);
{
NI k;
NI colontmp_;
NI i_2;
k = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = j;
{
while (1) {
if (!(i_2 < colontmp_)) goto LA6;
k = i_2;
{
if (!(((NI) 0) < generated)) goto LA9_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA9_: ;
genOtherArg__jsgen_3606(p, n, k, typ, (&generated), r);
i_2 += ((NI) 1);
} LA6: ;
}
}
i += ((NI) 1);
}
break;
case 35:
{
NI generated_2;
generated_2 = ((NI) 0);
genOtherArg__jsgen_3606(p, n, j, typ, (&generated_2), r);
j += ((NI) 1);
i += ((NI) 1);
}
break;
case 31:
{
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_389));
i += ((NI) 1);
}
break;
case 29:
{
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_390));
i += ((NI) 1);
}
break;
default:
{
NI start;
start = i;
{
while (1) {
if (!(i < (pat ? pat->Sup.len : 0))) goto LA16;
{
if (!!((((NU8)(pat->data[i])) == ((NU8)(64)) || ((NU8)(pat->data[i])) == ((NU8)(35)) || ((NU8)(pat->data[i])) == ((NU8)(31)) || ((NU8)(pat->data[i])) == ((NU8)(29))))) goto LA19_;
i += ((NI) 1);
}
goto LA17_;
LA19_: ;
{
goto LA15;
}
LA17_: ;
} LA16: ;
} LA15: ;
{
NimStringDesc* T26_;
if (!(start <= (NI)(i - ((NI) 1)))) goto LA24_;
T26_ = NIM_NIL;
T26_ = substr__system_7773(pat, start, (NI)(i - ((NI) 1)));
add__ropes_162(&(*r).res, T26_);
}
LA24_: ;
}
break;
}
} LA2: ;
}
}
N_LIB_PRIVATE N_NIMCALL(void, genInfixCall__jsgen_3688)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* f;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w op;
{ f = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
{
if (!((*f).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA3_;
asgnRef((void**) (&(*f).loc.r), mangleName__jsgen_308((*p).module, f));
}
LA3_: ;
{
NimStringDesc* pat;
if (!(((*f).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 32))&63U)))!=0)) goto LA7_;
pat = (*(*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).loc.r).data;
{
NimStringDesc* argX60gensym743_;
if (!!((((NI) 0) < (pat ? pat->Sup.len : 0)))) goto LA11_;
argX60gensym743_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_384);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym743_, TM__BxLwT0mhrtgTPodf1v3xjg_384);
}
LA11_: ;
{
NIM_BOOL T15_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
T15_ = (NIM_BOOL)0;
T15_ = contains__pureZstrutils_1635(pat, TM__BxLwT0mhrtgTPodf1v3xjg_385);
if (!T15_) goto LA16_;
typ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
genPatternCall__jsgen_3641(p, n, pat, typ, r);
goto BeforeRet_;
}
LA16_: ;
}
LA7_: ;
{
NI T20_;
T20_ = (NI)0;
T20_ = len__ast_3198(n);
if (!!((T20_ == ((NI) 1)))) goto LA21_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T31_;
if (!((*r).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA25_;
{
if (!((*r).address == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA29_;
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_391), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 2), TM__BxLwT0mhrtgTPodf1v3xjg_392, NIM_FALSE);
}
LA29_: ;
nimZeroMem((void*)T31_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T31_[0] = (*r).address;
T31_[1] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_6775(T31_, 2));
unsureAsgnRef((void**) (&(*r).address), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
LA25_: ;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_393));
}
LA21_: ;
nimZeroMem((void*)(&op), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&op));
add__ropes_159(&(*r).res, op.res);
genArgs__jsgen_3551(p, n, r, ((NI) 2));
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2940)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_397), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genSetConstr__jsgen_5219)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w b;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&b), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_394));
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_395)));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA6_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA6_: ;
it = (*n)._kind_6.sons->data[i];
{
if (!((*it).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 44))) goto LA10_;
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 0)], (&a));
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 1)], (&b));
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
if (!((*(*(*it)._kind_6.sons->data[((NI) 0)]).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1))) goto LA14_;
nimZeroMem((void*)T16_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T16_[0] = a.res;
T16_[1] = b.res;
T17_ = NIM_NIL;
T17_ = percent___cgen_11991(T16_, 2);
add__ropes_159(&(*r).res, T17_);
}
goto LA12_;
LA14_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
nimZeroMem((void*)T19_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T19_[0] = a.res;
T19_[1] = b.res;
T20_ = NIM_NIL;
T20_ = percent___jsgen_462(T19_, 2);
add__ropes_159(&(*r).res, T20_);
}
LA12_: ;
}
goto LA8_;
LA10_: ;
{
gen__jsgen_766(p, it, (&a));
add__ropes_159(&(*r).res, a.res);
}
LA8_: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
{
NIM_BOOL T24_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T28_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
T24_ = (NIM_BOOL)0;
T24_ = isDeepConstExpr__trees_171(n, NIM_FALSE);
if (!T24_) goto LA25_;
(*(*p).g).unique += ((NI) 1);
T27_ = NIM_NIL;
T27_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_396));
T28_ = NIM_NIL;
T28_ = rope__ropes_115(((NI64) ((*(*p).g).unique)));
tmp = amp___ropes_128(T27_, T28_);
nimZeroMem((void*)T29_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T29_[0] = tmp;
T29_[1] = (*r).res;
T30_ = NIM_NIL;
T30_ = percent___jsgen_2940(T29_, 2);
add__ropes_159(&(*(*p).g).constants, T30_);
unsureAsgnRef((void**) (&(*r).res), tmp);
}
LA25_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5275)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_398), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genArrayConstr__jsgen_5263)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyObject_TType__facALICuu8zUj0hjvbTLFg* e;
NimStringDesc* jsTyp;
t = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
e = elemType__types_263(t);
jsTyp = arrayTypeForElemType__jsgen_3959(e);
{
NIM_BOOL T3_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T4_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyArray__JiWwrsTRC6xqNlGcBthSVA T8_;
T3_ = (NIM_BOOL)0;
T4_ = NIM_NIL;
T4_ = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
T3_ = !(((*T4_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24)));
if (!(T3_)) goto LA5_;
T3_ = (((NI) 0) < (jsTyp ? jsTyp->Sup.len : 0));
LA5_: ;
if (!T3_) goto LA6_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)T8_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T8_[0] = rope__ropes_109(jsTyp);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5275(T8_, 1));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA11;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA14_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA14_: ;
gen__jsgen_766(p, (*n)._kind_6.sons->data[i], (&a));
add__ropes_159(&(*r).res, a.res);
i_2 += ((NI) 1);
} LA11: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_399));
}
goto LA1_;
LA6_: ;
{
genJSArrayConstr__jsgen_4569(p, n, r);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5314)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_400), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5323)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_401), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genTupleConstr__jsgen_5289)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_175)));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!(((NI) 0) < i)) goto LA6_;
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA6_: ;
it = (*n)._kind_6.sons->data[i];
{
if (!((*it).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 34))) goto LA10_;
it = (*it)._kind_6.sons->data[((NI) 1)];
}
LA10_: ;
gen__jsgen_766(p, it, (&a));
typ = skipTypes__ast_3735((*it).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA14_;
nimZeroMem((void*)T16_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T16_[0] = rope__ropes_115(((NI64) (i)));
T16_[1] = a.address;
T16_[2] = a.res;
T17_ = NIM_NIL;
T17_ = percent___jsgen_5314(T16_, 3);
add__ropes_159(&(*r).res, T17_);
}
goto LA12_;
LA14_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T25_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T26_;
{
NIM_BOOL T21_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T24_;
T21_ = (NIM_BOOL)0;
T21_ = needsNoCopy__jsgen_2483(p, it);
if (!!(T21_)) goto LA22_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T24_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T24_[0] = rdLoc__jsgen_188((&a));
T24_[1] = genTypeInfo__jsgen_385(p, typ);
a.res = percent___jsgen_4160(T24_, 2);
}
LA22_: ;
nimZeroMem((void*)T25_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T25_[0] = rope__ropes_115(((NI64) (i)));
T25_[1] = a.res;
T26_ = NIM_NIL;
T26_ = percent___jsgen_5323(T25_, 2);
add__ropes_159(&(*r).res, T26_);
}
LA12_: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
add__ropes_162(&(*r).res, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_177));
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5414)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_403), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5423)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_404), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5433)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_406), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genObjConstr__jsgen_5328)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* initList;
tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA fieldIDs;
tyObject_TType__facALICuu8zUj0hjvbTLFg* t;
tyArray__JiWwrsTRC6xqNlGcBthSVA T31_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
initList = NIM_NIL;
nimZeroMem((void*)(&fieldIDs), sizeof(tyObject_PackedSet__IhxwDBRi51nGrosBGFKcsA));
initIntSet__pureZcollectionsZintsets_238((&fieldIDs));
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 1);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* val;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* f;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym1086_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
{
if (!(((NI) 1) < i)) goto LA6_;
add__ropes_162(&initList, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA6_: ;
it = (*n)._kind_6.sons->data[i];
{
NimStringDesc* argX60gensym1082_;
if (!!(((*it).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 34)))) goto LA10_;
argX60gensym1082_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_402);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym1082_, TM__BxLwT0mhrtgTPodf1v3xjg_402);
}
LA10_: ;
val = (*it)._kind_6.sons->data[((NI) 1)];
gen__jsgen_766(p, val, (&a));
f = (*(*it)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
{
if (!((*f).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA14_;
asgnRef((void**) (&(*f).loc.r), mangleName__jsgen_308((*p).module, f));
}
LA14_: ;
xX60gensym1086_ = lookupFieldAgain__types_4062((*n).typ, f);
incl__pureZcollectionsZintsets_55((&fieldIDs), (NI)((NI)((NU64)(((NI) ((*xX60gensym1086_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym1086_).Sup.itemId.item))));
typ = skipTypes__ast_3735((*val).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T20_[0] = (*f).loc.r;
T20_[1] = a.address;
T20_[2] = a.res;
T21_ = NIM_NIL;
T21_ = percent___jsgen_5414(T20_, 3);
add__ropes_159(&initList, T21_);
}
goto LA16_;
LA18_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
{
NIM_BOOL T25_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T28_;
T25_ = (NIM_BOOL)0;
T25_ = needsNoCopy__jsgen_2483(p, val);
if (!!(T25_)) goto LA26_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T28_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T28_[0] = rdLoc__jsgen_188((&a));
T28_[1] = genTypeInfo__jsgen_385(p, typ);
a.res = percent___jsgen_4160(T28_, 2);
}
LA26_: ;
nimZeroMem((void*)T29_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T29_[0] = (*f).loc.r;
T29_[1] = a.res;
T30_ = NIM_NIL;
T30_ = percent___jsgen_5423(T29_, 2);
add__ropes_159(&initList, T30_);
}
LA16_: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
t = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_405);
createObjInitList__jsgen_3943(p, t, (&fieldIDs), &initList);
nimZeroMem((void*)T31_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T31_[0] = initList;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5433(T31_, 1));
}
static N_INLINE(NIM_BOOL, contains__semfold_938)(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA s, tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag value) {
NIM_BOOL result;
NIM_BOOL T1_;
result = (NIM_BOOL)0;
T1_ = (NIM_BOOL)0;
T1_ = (s.a <= value);
if (!(T1_)) goto LA2_;
T1_ = (value <= s.b);
LA2_: ;
result = T1_;
return result;
}
static N_INLINE(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA, dotdot___semfold_916)(tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag a, tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag b) {
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA result;
nimZeroMem((void*)(&result), sizeof(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA));
nimZeroMem((void*)(&result), sizeof(tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA));
result.a = a;
result.b = b;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5711)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_407), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5720)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_408), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5725)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_409), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genConv__jsgen_5438)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* dest;
tyObject_TType__facALICuu8zUj0hjvbTLFg* src;
NIM_BOOL toInt;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T5_;
NIM_BOOL fromInt;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T6_;
NIM_BOOL toUint;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T7_;
NIM_BOOL fromUint;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T8_;
{ dest = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
src = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
{
if (!((*dest).kind == (*src).kind)) goto LA3_;
goto BeforeRet_;
}
LA3_: ;
T5_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 34));
toInt = contains__semfold_938(T5_, (*dest).kind);
T6_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 34));
fromInt = contains__semfold_938(T6_, (*src).kind);
T7_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 43));
toUint = contains__semfold_938(T7_, (*dest).kind);
T8_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 43));
fromUint = contains__semfold_938(T8_, (*src).kind);
{
NIM_BOOL T11_;
NIM_BOOL T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* trimmer;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T17_;
T11_ = (NIM_BOOL)0;
T11_ = toUint;
if (!(T11_)) goto LA12_;
T13_ = (NIM_BOOL)0;
T13_ = fromInt;
if (T13_) goto LA14_;
T13_ = fromUint;
LA14_: ;
T11_ = T13_;
LA12_: ;
if (!T11_) goto LA15_;
trimmer = unsignedTrimmerJS__jsgen_1101((*dest).size);
nimZeroMem((void*)T17_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_[0] = (*r).res;
T17_[1] = trimmer;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5711(T17_, 2));
}
goto LA9_;
LA15_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T21_;
if (!((*dest).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1))) goto LA19_;
nimZeroMem((void*)T21_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T21_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5720(T21_, 1));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
goto LA9_;
LA19_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T25_;
if (!toInt) goto LA23_;
nimZeroMem((void*)T25_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T25_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5725(T25_, 1));
}
goto LA9_;
LA23_: ;
{
}
LA9_: ;
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, addQuoted__jsgen_3158)(NimStringDesc** s, tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw x) {
unsureAsgnRef((void**) (&(*s)), resizeString((*s), (reprEnum((NI)x, (&NTItsymkind__cNCW9acsSznmEccl1fgQwkw_)) ? reprEnum((NI)x, (&NTItsymkind__cNCW9acsSznmEccl1fgQwkw_))->Sup.len : 0) + 0));
appendString((*s), reprEnum((NI)x, (&NTItsymkind__cNCW9acsSznmEccl1fgQwkw_)));
}
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___jsgen_3124)(tyTuple__Fb1Z8PVtzpSjrvQ67oA88w x) {
NimStringDesc* result;
NI count;
result = NIM_NIL;
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_117));
count = ((NI) 0);
{
if (!(((NI) 0) < count)) goto LA3_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA3_: ;
count += ((NI) 1);
addQuoted__pureZos_431((&result), x.Field0);
{
if (!(((NI) 0) < count)) goto LA7_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA7_: ;
count += ((NI) 1);
addQuoted__jsgen_3158((&result), x.Field1);
{
if (!(count == ((NI) 1))) goto LA11_;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_413));
}
LA11_: ;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2956)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_421), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2946)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_422), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2951)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_423), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genCheckedFieldOp__jsgen_2879)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TType__facALICuu8zUj0hjvbTLFg* addrTyp, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* accessExpr;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* checkExpr;
NIM_BOOL negCheck;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* field;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* disc;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w setx;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w obj;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T26_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T28_;
NimStringDesc* msg;
tyArray__dNfZYyzVYdaWfURv4pxodA T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T37_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T38_;
{
NimStringDesc* argX60gensym583_;
if (!!(((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 46)))) goto LA3_;
argX60gensym583_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_416);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym583_, TM__BxLwT0mhrtgTPodf1v3xjg_416);
}
LA3_: ;
accessExpr = (*n)._kind_6.sons->data[((NI) 0)];
checkExpr = (*n)._kind_6.sons->data[((NI) 1)];
negCheck = ((*(*(*checkExpr)._kind_6.sons->data[((NI) 0)])._kind_4.sym).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 96));
{
NI T9_;
if (!negCheck) goto LA7_;
T9_ = (NI)0;
T9_ = len__ast_3198(checkExpr);
checkExpr = (*checkExpr)._kind_6.sons->data[(NI)(T9_ - ((NI) 1))];
}
LA7_: ;
field = (*(*accessExpr)._kind_6.sons->data[((NI) 1)])._kind_4.sym;
{
NimStringDesc* argX60gensym593_;
if (!!(((*field).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 19)))) goto LA12_;
argX60gensym593_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_417);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym593_, TM__BxLwT0mhrtgTPodf1v3xjg_417);
}
LA12_: ;
{
if (!((*field).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA16_;
asgnRef((void**) (&(*field).loc.r), mangleName__jsgen_308((*p).module, field));
}
LA16_: ;
disc = (*(*checkExpr)._kind_6.sons->data[((NI) 2)])._kind_4.sym;
{
NimStringDesc* argX60gensym597_;
if (!!(((*disc).kind == ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 19)))) goto LA20_;
argX60gensym597_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_418);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym597_, TM__BxLwT0mhrtgTPodf1v3xjg_418);
}
LA20_: ;
{
if (!((*disc).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA24_;
asgnRef((void**) (&(*disc).loc.r), mangleName__jsgen_308((*p).module, disc));
}
LA24_: ;
nimZeroMem((void*)(&setx), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*checkExpr)._kind_6.sons->data[((NI) 1)], (&setx));
nimZeroMem((void*)(&obj), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*accessExpr)._kind_6.sons->data[((NI) 0)], (&obj));
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T26_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T26_[0] = tmp;
T26_[1] = obj.res;
T27_ = NIM_NIL;
T27_ = percent___jsgen_2940(T26_, 2);
T28_ = NIM_NIL;
T28_ = indentLine__jsgen_97(p, T27_);
add__ropes_159(&(*p).body, T28_);
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_419));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_212));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_420));
msg = genFieldDefect__astmsgs_61((*(*p).module).config, (*(*field).name).s, disc);
nimZeroMem((void*)T29_, sizeof(tyArray__dNfZYyzVYdaWfURv4pxodA));
T29_[0] = setx.res;
T29_[1] = tmp;
T29_[2] = (*disc).loc.r;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T34_;
if (!negCheck) goto LA32_;
nimZeroMem((void*)T34_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T29_[3] = percent___jsgen_2946(T34_, 0);
}
goto LA30_;
LA32_: ;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T36_;
nimZeroMem((void*)T36_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T29_[3] = percent___jsgen_2951(T36_, 0);
}
LA30_: ;
T29_[4] = makeJSString__jsgen_378(msg, NIM_TRUE);
T29_[5] = genTypeInfo__jsgen_385(p, (*disc).typ);
T37_ = NIM_NIL;
T37_ = percent___jsgen_2956(T29_, 6);
T38_ = NIM_NIL;
T38_ = indentLine__jsgen_97(p, T37_);
add__ropes_159(&(*p).body, T38_);
{
NIM_BOOL T41_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T43_;
NimStringDesc* T46_;
T41_ = (NIM_BOOL)0;
T41_ = !((addrTyp == ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL)));
if (!(T41_)) goto LA42_;
T43_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T43_ = mapType__jsgen_304(p, addrTyp);
T41_ = (T43_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA42_: ;
if (!T41_) goto LA44_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
T46_ = NIM_NIL;
T46_ = dollar___ropes_250((*field).loc.r);
unsureAsgnRef((void**) (&(*r).res), makeJSString__jsgen_378(T46_, NIM_TRUE));
unsureAsgnRef((void**) (&(*r).address), tmp);
}
goto LA39_;
LA44_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T48_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
nimZeroMem((void*)T48_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T48_[0] = tmp;
T48_[1] = (*field).loc.r;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_7439(T48_, 2));
}
LA39_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(NI, getFieldPosition__jsgen_2749)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* f) {
NI result;
result = (NI)0;
switch ((*f).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 6) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 15):
{
result = ((NI) ((*f)._kind_1.intVal));
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
result = (*(*f)._kind_4.sym).position;
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*f).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_425), TM__BxLwT0mhrtgTPodf1v3xjg_426);
}
break;
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genFieldAddr__jsgen_2753)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* b;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
{
if (!((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 64))) goto LA3_;
b = (*n)._kind_6.sons->data[((NI) 0)];
}
goto LA1_;
LA3_: ;
{
b = n;
}
LA1_: ;
gen__jsgen_766(p, (*b)._kind_6.sons->data[((NI) 0)], (&a));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T8_;
NimStringDesc* T11_;
NI T12_;
NimStringDesc* T13_;
T8_ = NIM_NIL;
T8_ = skipTypes__ast_3735((*(*b)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T8_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18))) goto LA9_;
T11_ = NIM_NIL;
T12_ = (NI)0;
T12_ = getFieldPosition__jsgen_2749(p, (*b)._kind_6.sons->data[((NI) 1)]);
T13_ = NIM_NIL;
T13_ = dollar___systemZdollars_3(T12_);
T11_ = rawNewString((T13_ ? T13_->Sup.len : 0) + 5);
appendString(T11_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_424));
appendString(T11_, T13_);
unsureAsgnRef((void**) (&(*r).res), makeJSString__jsgen_378(T11_, NIM_TRUE));
}
goto LA6_;
LA9_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* f;
NimStringDesc* T23_;
{
if (!!(((*(*b)._kind_6.sons->data[((NI) 1)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3)))) goto LA17_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*b)._kind_6.sons->data[((NI) 1)]).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_427), TM__BxLwT0mhrtgTPodf1v3xjg_428);
}
LA17_: ;
f = (*(*b)._kind_6.sons->data[((NI) 1)])._kind_4.sym;
{
if (!((*f).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA21_;
asgnRef((void**) (&(*f).loc.r), mangleName__jsgen_308((*p).module, f));
}
LA21_: ;
T23_ = NIM_NIL;
T23_ = dollar___ropes_250((*f).loc.r);
unsureAsgnRef((void**) (&(*r).res), makeJSString__jsgen_378(T23_, NIM_TRUE));
}
LA6_: ;
{
NimStringDesc* argX60gensym566_;
if (!!(!((a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))))) goto LA26_;
argX60gensym566_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_429);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym566_, TM__BxLwT0mhrtgTPodf1v3xjg_429);
}
LA26_: ;
unsureAsgnRef((void**) (&(*r).address), a.res);
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, genFieldAccess__jsgen_2791)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* otyp;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
(*r).typ = mapType__jsgen_277((*n).typ);
otyp = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T5_;
NI T6_;
if (!((*otyp).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18))) goto LA3_;
nimZeroMem((void*)T5_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T5_[0] = (*r).res;
T6_ = (NI)0;
T6_ = getFieldPosition__jsgen_2749(p, (*n)._kind_6.sons->data[((NI) 1)]);
T5_[1] = rope__ropes_115(((NI64) (T6_)));
unsureAsgnRef((void**) (&(*r).res), percent___cgen_13309(T5_, 2));
{
if (!((*r).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA9_;
{
NIM_BOOL T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym571_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T16_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T17_;
T13_ = (NIM_BOOL)0;
T13_ = needsTemp__jsgen_951(p, (*n)._kind_6.sons->data[((NI) 0)]);
if (!T13_) goto LA14_;
tmpX60gensym571_ = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T16_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T16_[0] = tmpX60gensym571_;
T16_[1] = (*r).res;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2817(T16_, 2));
nimZeroMem((void*)T17_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T17_[0] = tmpX60gensym571_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T17_, 1));
unsureAsgnRef((void**) (&(*r).tmpLoc), tmpX60gensym571_);
}
goto LA11_;
LA14_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T19_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T20_;
nimZeroMem((void*)T19_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T19_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2827(T19_, 1));
nimZeroMem((void*)T20_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T20_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T20_, 1));
}
LA11_: ;
}
LA9_: ;
}
goto LA1_;
LA3_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* f;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T30_;
{
if (!!(((*(*n)._kind_6.sons->data[((NI) 1)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3)))) goto LA24_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*n)._kind_6.sons->data[((NI) 1)]).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_430), TM__BxLwT0mhrtgTPodf1v3xjg_431);
}
LA24_: ;
f = (*(*n)._kind_6.sons->data[((NI) 1)])._kind_4.sym;
{
if (!((*f).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA28_;
asgnRef((void**) (&(*f).loc.r), mangleName__jsgen_308((*p).module, f));
}
LA28_: ;
nimZeroMem((void*)T30_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T30_[0] = (*r).res;
T30_[1] = (*f).loc.r;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_7439(T30_, 2));
{
if (!((*r).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA33_;
{
NIM_BOOL T37_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpX60gensym580_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T40_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T41_;
T37_ = (NIM_BOOL)0;
T37_ = needsTemp__jsgen_951(p, (*n)._kind_6.sons->data[((NI) 1)]);
if (!T37_) goto LA38_;
tmpX60gensym580_ = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T40_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T40_[0] = tmpX60gensym580_;
T40_[1] = (*r).res;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2817(T40_, 2));
nimZeroMem((void*)T41_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T41_[0] = tmpX60gensym580_;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T41_, 1));
unsureAsgnRef((void**) (&(*r).tmpLoc), tmpX60gensym580_);
}
goto LA35_;
LA38_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T43_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T44_;
nimZeroMem((void*)T43_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T43_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2827(T43_, 1));
nimZeroMem((void*)T44_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T44_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T44_, 1));
}
LA35_: ;
}
LA33_: ;
}
LA1_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, genArrayAddr__jsgen_2973)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w b;
tyObject_Int128__9a9axPfb75jdWY25AamJewkA first;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* m;
tyTuple__nsNHL3sm0TZE9bootw2pEXw T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* x;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&b), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&first), sizeof(tyObject_Int128__9a9axPfb75jdWY25AamJewkA));
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
{
if (!((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 64))) goto LA3_;
m = (*n)._kind_6.sons->data[((NI) 0)];
}
goto LA1_;
LA3_: ;
{
m = n;
}
LA1_: ;
gen__jsgen_766(p, (*m)._kind_6.sons->data[((NI) 0)], (&a));
gen__jsgen_766(p, (*m)._kind_6.sons->data[((NI) 1)], (&b));
nimZeroMem((void*)(&T6_), sizeof(tyTuple__nsNHL3sm0TZE9bootw2pEXw));
maybeMakeTemp__jsgen_964(p, (*m)._kind_6.sons->data[((NI) 0)], (&a), (&T6_));
x = NIM_NIL;
x = T6_.Field0;
tmp = NIM_NIL;
tmp = T6_.Field1;
unsureAsgnRef((void**) (&(*r).address), x);
typ = skipTypes__ast_3735((*(*m)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_334);
{
if (!((*typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16))) goto LA9_;
first = firstOrd__types_1353((*(*p).module).config, (*typ).sons->data[((NI) 0)]);
}
LA9_: ;
{
if (!(((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 4))&31U)))!=0)) goto LA13_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_335));
{
NIM_BOOL T17_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T20_;
T17_ = (NIM_BOOL)0;
T17_ = eqeq___int495056_759(first, IL64(0));
if (!T17_) goto LA18_;
nimZeroMem((void*)T20_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T20_[0] = b.res;
T20_[1] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1056(T20_, 2));
}
goto LA15_;
LA18_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T22_;
nimZeroMem((void*)T22_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T22_[0] = b.res;
T22_[1] = rope__jsgen_382(first);
T22_[2] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1061(T22_, 3));
}
LA15_: ;
}
goto LA11_;
LA13_: ;
{
NIM_BOOL T24_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T27_;
T24_ = (NIM_BOOL)0;
T24_ = eqeq___int495056_759(first, IL64(0));
if (!!(T24_)) goto LA25_;
nimZeroMem((void*)T27_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T27_[0] = b.res;
T27_[1] = rope__jsgen_382(first);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1066(T27_, 2));
}
goto LA11_;
LA25_: ;
{
unsureAsgnRef((void**) (&(*r).res), b.res);
}
LA11_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, genAddr__jsgen_2875)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
switch ((*(*n)._kind_6.sons->data[((NI) 0)]).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s;
s = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
{
if (!((*s).loc.r == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA4_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_410), TM__BxLwT0mhrtgTPodf1v3xjg_411);
}
LA4_: ;
switch ((*s).kind) {
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 3):
{
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
unsureAsgnRef((void**) (&(*r).address), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
break;
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 8):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 9):
case ((tyEnum_TSymKind__cNCW9acsSznmEccl1fgQwkw) 11):
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA jsType;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
jsType = mapType__jsgen_304(p, (*n).typ);
{
if (!(jsType == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8))) goto LA10_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* vX60gensym630_;
NIM_BOOL T14_;
NIM_BOOL T15_;
vX60gensym630_ = s;
T14_ = (NIM_BOOL)0;
T15_ = (NIM_BOOL)0;
T15_ = !(((131080 & (*vX60gensym630_).flags) == 0));
if (!(T15_)) goto LA16_;
T15_ = ((192 & (*vX60gensym630_).flags) == 0);
LA16_: ;
T14_ = T15_;
if (!(T14_)) goto LA17_;
T14_ = !(((128544 &((NU32)1<<((NU)((*vX60gensym630_).kind)&31U)))!=0));
LA17_: ;
if (!T14_) goto LA18_;
unsureAsgnRef((void**) (&(*r).res), amp___ropes_140((*s).loc.r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_412)));
}
goto LA12_;
LA18_: ;
{
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
}
LA12_: ;
unsureAsgnRef((void**) (&(*r).address), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
goto LA8_;
LA10_: ;
{
NIM_BOOL T22_;
T22_ = (NIM_BOOL)0;
T22_ = !(((131080 & (*s).flags) == 0));
if (T22_) goto LA23_;
T22_ = (jsType == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9));
LA23_: ;
if (!T22_) goto LA24_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
unsureAsgnRef((void**) (&(*r).address), (*s).loc.r);
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_105)));
}
goto LA8_;
LA24_: ;
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
LA8_: ;
}
break;
default:
{
tyTuple__Fb1Z8PVtzpSjrvQ67oA88w T28_;
NimStringDesc* T29_;
nimZeroMem((void*)(&T28_), sizeof(tyTuple__Fb1Z8PVtzpSjrvQ67oA88w));
T28_.Field0 = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_414));
T28_.Field1 = (*s).kind;
T29_ = NIM_NIL;
T29_ = dollar___jsgen_3124(T28_);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T29_, TM__BxLwT0mhrtgTPodf1v3xjg_415);
}
break;
}
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 46):
{
genCheckedFieldOp__jsgen_2879(p, (*n)._kind_6.sons->data[((NI) 0)], (*n).typ, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 45):
{
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T34_;
T34_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T34_ = mapType__jsgen_304(p, (*n).typ);
if (!(T34_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA35_;
genFieldAddr__jsgen_2753(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
goto LA32_;
LA35_: ;
{
genFieldAccess__jsgen_2791(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
LA32_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 42):
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* ty;
ty = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
{
if (!((*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 17) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 19) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48))) goto LA41_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
goto LA39_;
LA41_: ;
{
tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag kindOfIndexedExpr;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T44_;
T44_ = NIM_NIL;
T44_ = skipTypes__ast_3735((*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
kindOfIndexedExpr = (*T44_).kind;
switch (kindOfIndexedExpr) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48):
{
genArrayAddr__jsgen_2973(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18):
{
genFieldAddr__jsgen_2753(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
default:
{
NimStringDesc* T48_;
T48_ = NIM_NIL;
T48_ = rawNewString((reprEnum((NI)kindOfIndexedExpr, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)kindOfIndexedExpr, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 21);
appendString(T48_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_432));
appendString(T48_, reprEnum((NI)kindOfIndexedExpr, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
appendChar(T48_, 41);
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*n)._kind_6.sons->data[((NI) 0)]).info, T48_, TM__BxLwT0mhrtgTPodf1v3xjg_433);
}
break;
}
}
LA39_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 66):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 65):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 64):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 126):
{
{
NI T55_;
T55_ = (NI)0;
T55_ = len__ast_3198(n);
if (!(T55_ == ((NI) 1))) goto LA56_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
goto LA53_;
LA56_: ;
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*n)._kind_6.sons->data[((NI) 0)]).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_434), TM__BxLwT0mhrtgTPodf1v3xjg_435);
}
LA53_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32):
{
{
if (!((*(*(*n)._kind_6.sons->data[((NI) 0)]).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27))) goto LA62_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
goto LA60_;
LA62_: ;
{
NimStringDesc* T65_;
T65_ = NIM_NIL;
T65_ = rawNewString((reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)) ? reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_))->Sup.len : 0) + 9);
appendString(T65_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_436));
appendString(T65_, reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)));
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*n)._kind_6.sons->data[((NI) 0)]).info, T65_, TM__BxLwT0mhrtgTPodf1v3xjg_437);
}
LA60_: ;
}
break;
default:
{
NimStringDesc* T67_;
T67_ = NIM_NIL;
T67_ = rawNewString((reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)) ? reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_))->Sup.len : 0) + 9);
appendString(T67_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_436));
appendString(T67_, reprEnum((NI)(*(*n)._kind_6.sons->data[((NI) 0)]).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)));
internalErrorImpl__msgs_1431((*(*p).module).config, (*(*n)._kind_6.sons->data[((NI) 0)]).info, T67_, TM__BxLwT0mhrtgTPodf1v3xjg_438);
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(void, genDeref__jsgen_3452)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA t;
it = (*n)._kind_6.sons->data[((NI) 0)];
t = mapType__jsgen_304(p, (*it).typ);
{
if (!(t == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8))) goto LA3_;
gen__jsgen_766(p, it, r);
}
goto LA1_;
LA3_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, it, (&a));
(*r).kind = a.kind;
(*r).typ = mapType__jsgen_304(p, (*n).typ);
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T10_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T11_;
if (!((*r).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA8_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T10_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T10_[0] = tmp;
T10_[1] = rdLoc__jsgen_188((&a));
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2817(T10_, 2));
nimZeroMem((void*)T11_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T11_[0] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T11_, 1));
unsureAsgnRef((void**) (&(*r).tmpLoc), tmp);
}
goto LA6_;
LA8_: ;
{
if (!(a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA13_;
{
if (!!((a.tmpLoc == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA17_;
unsureAsgnRef((void**) (&(*r).tmpLoc), a.tmpLoc);
}
LA17_: ;
unsureAsgnRef((void**) (&(*r).res), rdLoc__jsgen_188((&a)));
}
goto LA6_;
LA13_: ;
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_439), TM__BxLwT0mhrtgTPodf1v3xjg_440);
}
LA6_: ;
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_3038)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_444), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genArrayAccess__jsgen_3014)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* ty;
ty = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T5_;
if (!((*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 22) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 47) || (*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 45))) goto LA3_;
T5_ = NIM_NIL;
T5_ = lastSon__ast_3743(ty);
ty = skipTypes__ast_3735(T5_, TM__BxLwT0mhrtgTPodf1v3xjg_211);
}
LA3_: ;
switch ((*ty).kind) {
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 16):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 27):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29):
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 48):
{
genArrayAddr__jsgen_2973(p, n, r);
}
break;
case ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 18):
{
genFieldAddr__jsgen_2753(p, n, r);
}
break;
default:
{
NimStringDesc* T9_;
T9_ = NIM_NIL;
T9_ = rawNewString((reprEnum((NI)(*ty).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)) ? reprEnum((NI)(*ty).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_))->Sup.len : 0) + 21);
appendString(T9_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_432));
appendString(T9_, reprEnum((NI)(*ty).kind, (&NTIttypekind__9a3YiReNVD0IJHWFKgXRe9ag_)));
appendChar(T9_, 41);
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T9_, TM__BxLwT0mhrtgTPodf1v3xjg_441);
}
break;
}
(*r).typ = mapType__jsgen_277((*n).typ);
{
if (!((*r).res == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA12_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_442), TM__BxLwT0mhrtgTPodf1v3xjg_443);
}
LA12_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T18_;
if (!((*ty).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29))) goto LA16_;
nimZeroMem((void*)T18_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T18_[0] = (*r).address;
T18_[1] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_3038(T18_, 2));
}
goto LA14_;
LA16_: ;
{
if (!((*r).typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA20_;
{
NIM_BOOL T24_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T27_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T28_;
T24_ = (NIM_BOOL)0;
T24_ = needsTemp__jsgen_951(p, (*n)._kind_6.sons->data[((NI) 0)]);
if (!T24_) goto LA25_;
tmp = getTemp__jsgen_838(p, NIM_TRUE);
nimZeroMem((void*)T27_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T27_[0] = tmp;
T27_[1] = rdLoc__jsgen_188((&(*r)));
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2817(T27_, 2));
nimZeroMem((void*)T28_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T28_[0] = tmp;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T28_, 1));
unsureAsgnRef((void**) (&(*r).tmpLoc), tmp);
}
goto LA22_;
LA25_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* x;
tyArray__JiWwrsTRC6xqNlGcBthSVA T30_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T31_;
x = rdLoc__jsgen_188((&(*r)));
nimZeroMem((void*)T30_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T30_[0] = x;
unsureAsgnRef((void**) (&(*r).address), percent___jsgen_2827(T30_, 1));
nimZeroMem((void*)T31_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T31_[0] = x;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_2822(T31_, 1));
}
LA22_: ;
}
goto LA14_;
LA20_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T33_;
nimZeroMem((void*)T33_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T33_[0] = (*r).address;
T33_[1] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___cgen_6775(T33_, 2));
}
LA14_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
N_LIB_PRIVATE N_NIMCALL(void, upConv__jsgen_5730)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6324)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_445), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6331)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_449), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6348)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_67), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genCast__jsgen_6047)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TType__facALICuu8zUj0hjvbTLFg* dest;
tyObject_TType__facALICuu8zUj0hjvbTLFg* src;
NIM_BOOL toInt;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T5_;
NIM_BOOL toUint;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T6_;
NIM_BOOL fromInt;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T7_;
NIM_BOOL fromUint;
tyObject_HSlice__HjDAjiFsTWGmlZ9cd8nEusA T8_;
{ dest = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
src = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 1)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
{
if (!((*dest).kind == (*src).kind)) goto LA3_;
goto BeforeRet_;
}
LA3_: ;
T5_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 34));
toInt = contains__semfold_938(T5_, (*dest).kind);
T6_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 43));
toUint = contains__semfold_938(T6_, (*dest).kind);
T7_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 31), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 34));
fromInt = contains__semfold_938(T7_, (*src).kind);
T8_ = dotdot___semfold_916(((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40), ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 43));
fromUint = contains__semfold_938(T8_, (*src).kind);
{
NIM_BOOL T11_;
NIM_BOOL T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* trimmer;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T17_;
T11_ = (NIM_BOOL)0;
T11_ = toUint;
if (!(T11_)) goto LA12_;
T13_ = (NIM_BOOL)0;
T13_ = fromInt;
if (T13_) goto LA14_;
T13_ = fromUint;
LA14_: ;
T11_ = T13_;
LA12_: ;
if (!T11_) goto LA15_;
trimmer = unsignedTrimmerJS__jsgen_1101((*dest).size);
nimZeroMem((void*)T17_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T17_[0] = (*r).res;
T17_[1] = trimmer;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5711(T17_, 2));
}
goto LA9_;
LA15_: ;
{
if (!toInt) goto LA19_;
{
if (!fromInt) goto LA23_;
goto BeforeRet_;
}
goto LA21_;
LA23_: ;
{
if (!fromUint) goto LA26_;
{
NIM_BOOL T30_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T34_;
T30_ = (NIM_BOOL)0;
T30_ = ((*src).size == IL64(4));
if (!(T30_)) goto LA31_;
T30_ = ((*dest).size == IL64(4));
LA31_: ;
if (!T30_) goto LA32_;
nimZeroMem((void*)T34_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T34_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_6324(T34_, 1));
}
goto LA28_;
LA32_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* trimmer_2;
NimStringDesc* minuend;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T40_;
trimmer_2 = unsignedTrimmerJS__jsgen_1101((*dest).size);
switch ((*dest).size) {
case ((NI) 1):
{
minuend = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_446));
}
break;
case ((NI) 2):
{
minuend = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_447));
}
break;
case ((NI) 4):
{
minuend = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_448));
}
break;
default:
{
minuend = ((NimStringDesc*) NIM_NIL);
}
break;
}
nimZeroMem((void*)T40_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T40_[0] = rope__ropes_109(minuend);
T40_[1] = (*r).res;
T40_[2] = trimmer_2;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_6331(T40_, 3));
}
LA28_: ;
}
goto LA21_;
LA26_: ;
LA21_: ;
}
goto LA9_;
LA19_: ;
{
NIM_BOOL T42_;
NIM_BOOL T43_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T45_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T49_;
T42_ = (NIM_BOOL)0;
T43_ = (NIM_BOOL)0;
T43_ = ((*src).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21));
if (!(T43_)) goto LA44_;
T45_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T45_ = mapType__jsgen_304(p, src);
T43_ = (T45_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8));
LA44_: ;
T42_ = T43_;
if (!(T42_)) goto LA46_;
T42_ = ((*dest).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26));
LA46_: ;
if (!T42_) goto LA47_;
unsureAsgnRef((void**) (&(*r).address), (*r).res);
nimZeroMem((void*)T49_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_6348(T49_, 0));
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
}
goto LA9_;
LA47_: ;
{
NIM_BOOL T51_;
NIM_BOOL T52_;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T54_;
T51_ = (NIM_BOOL)0;
T52_ = (NIM_BOOL)0;
T52_ = ((*dest).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21));
if (!(T52_)) goto LA53_;
T54_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T54_ = mapType__jsgen_304(p, dest);
T52_ = (T54_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8));
LA53_: ;
T51_ = T52_;
if (!(T51_)) goto LA55_;
T51_ = ((*src).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26));
LA55_: ;
if (!T51_) goto LA56_;
unsureAsgnRef((void**) (&(*r).res), (*r).address);
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8);
}
goto LA9_;
LA56_: ;
LA9_: ;
}BeforeRet_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5757)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_451), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genRangeChck__jsgen_5735)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r, NimStringDesc* magic) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w b;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&b), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
{
NIM_BOOL T3_;
NIM_BOOL T5_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T6_;
T3_ = (NIM_BOOL)0;
T3_ = !((((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 3))&31U)))!=0));
if (T3_) goto LA4_;
T5_ = (NIM_BOOL)0;
T6_ = NIM_NIL;
T6_ = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
T5_ = ((*T6_).kind >= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 40) && (*T6_).kind <= ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 44));
if (!(T5_)) goto LA7_;
T5_ = !((((*(*(*p).module).config).legacyFeatures &((NU8)1<<((NU)(((tyEnum_LegacyFeature__hGCD9aOrxPvpXn4Ne6W6OVA) 1))&7U)))!=0));
LA7_: ;
T3_ = T5_;
LA4_: ;
if (!T3_) goto LA8_;
}
goto LA1_;
LA8_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T11_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], (&a));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 2)], (&b));
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_450));
nimZeroMem((void*)T11_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T11_[0] = (*r).res;
T11_[1] = a.res;
T11_[2] = b.res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5757(T11_, 3));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5778)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_456), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, convStrToCStr__jsgen_5762)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
{
if (!((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 72))) goto LA3_;
gen__jsgen_766(p, (*(*n)._kind_6.sons->data[((NI) 0)])._kind_6.sons->data[((NI) 0)], r);
}
goto LA1_;
LA3_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
{
if (!((*r).res == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA8_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_454), TM__BxLwT0mhrtgTPodf1v3xjg_455);
}
LA8_: ;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_373));
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_5778(T10_, 1));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, convCStrToStr__jsgen_5783)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
{
if (!((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 71))) goto LA3_;
gen__jsgen_766(p, (*(*n)._kind_6.sons->data[((NI) 0)])._kind_6.sons->data[((NI) 0)], r);
}
goto LA1_;
LA3_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
{
if (!((*r).res == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL))) goto LA8_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_457), TM__BxLwT0mhrtgTPodf1v3xjg_458);
}
LA8_: ;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_249));
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = (*r).res;
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_1684(T10_, 1));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2273)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_461), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genBlock__jsgen_2248)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
NI idx;
NI T1_;
NI labl;
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
(*p).unique += ((NI) 1);
T1_ = ((*p).blocks ? (*p).blocks->Sup.len : 0);
idx = T1_;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* sym;
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1)))) goto LA4_;
{
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3)))) goto LA8_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_459), TM__BxLwT0mhrtgTPodf1v3xjg_460);
}
LA8_: ;
sym = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
(*sym).loc.k = ((tyEnum_TLocKind__O7PRFZKuiBBWbku09cayVBg) 10);
(*sym).position = (NI)(idx + ((NI) 1));
}
LA4_: ;
labl = (*p).unique;
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = rope__ropes_115(((NI64) (labl)));
T11_ = NIM_NIL;
T11_ = percent___jsgen_2273(T10_, 1);
T12_ = NIM_NIL;
T12_ = indentLine__jsgen_97(p, T11_);
add__ropes_159(&(*p).body, T12_);
asgnRef((void**) (&(*p).blocks), (tySequence__8fytVdU59b5aj319cog2ztLw*) setLengthSeqV2(&((*p).blocks)->Sup, (&NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_), ((NI) ((NI)(idx + ((NI) 1))))));
(*p).blocks->data[idx].id = ((NI64)-((*p).unique));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 1)], r);
asgnRef((void**) (&(*p).blocks), (tySequence__8fytVdU59b5aj319cog2ztLw*) setLengthSeqV2(&((*p).blocks)->Sup, (&NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_), ((NI) (idx))));
nimZeroMem((void*)T13_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T13_[0] = rope__ropes_115(((NI64) (labl)));
T14_ = NIM_NIL;
T14_ = percent___jsgen_2287(T13_, 1);
T15_ = NIM_NIL;
T15_ = indentLine__jsgen_97(p, T14_);
add__ropes_159(&(*p).body, T15_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2012)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_462), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2395)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_463), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, moveInto__jsgen_1938)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* src, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* dest) {
{
if (!!(((*src).kind == ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 0)))) goto LA3_;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
if (!!(((*dest).kind == ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 0)))) goto LA7_;
nimZeroMem((void*)T9_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T9_[0] = rdLoc__jsgen_188(dest);
T9_[1] = rdLoc__jsgen_188((&(*src)));
T10_ = NIM_NIL;
T10_ = percent___jsgen_1950(T9_, 2);
T11_ = NIM_NIL;
T11_ = indentLine__jsgen_97(p, T10_);
add__ropes_159(&(*p).body, T11_);
}
goto LA5_;
LA7_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T15_;
nimZeroMem((void*)T13_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T13_[0] = rdLoc__jsgen_188((&(*src)));
T14_ = NIM_NIL;
T14_ = percent___cgen_7770(T13_, 1);
T15_ = NIM_NIL;
T15_ = indentLine__jsgen_97(p, T14_);
add__ropes_159(&(*p).body, T15_);
}
LA5_: ;
(*src).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 0);
unsureAsgnRef((void**) (&(*src).res), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
LA3_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genIf__jsgen_2358)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w cond;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w stmt;
NI toClose;
NimStringDesc* T31_;
NimStringDesc* T32_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T33_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T34_;
nimZeroMem((void*)(&cond), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&stmt), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
toClose = ((NI) 0);
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = isEmptyType__ast_4779((*n).typ);
if (!!(T3_)) goto LA4_;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
}
LA4_: ;
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
tyArray__qTjAvTvKF9anytN1At69aJMQ T28_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
if (!(i_2 < colontmp_)) goto LA8;
i = i_2;
it = (*n)._kind_6.sons->data[i];
{
NI T11_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T21_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T23_;
T11_ = (NI)0;
T11_ = len__ast_3198(it);
if (!!((T11_ == ((NI) 1)))) goto LA12_;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T18_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
if (!(((NI) 0) < i)) goto LA16_;
nimZeroMem((void*)T18_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T19_ = NIM_NIL;
T19_ = percent___jsgen_2012(T18_, 0);
T20_ = NIM_NIL;
T20_ = indentLine__jsgen_97(p, T19_);
add__ropes_159(&(*p).body, T20_);
toClose += ((NI) 1);
}
LA16_: ;
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 0)], (&cond));
(*p).extraIndent -= ((NI) 1);
nimZeroMem((void*)T21_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T21_[0] = rdLoc__jsgen_188((&cond));
T22_ = NIM_NIL;
T22_ = percent___jsgen_2395(T21_, 1);
T23_ = NIM_NIL;
T23_ = indentLine__jsgen_97(p, T22_);
add__ropes_159(&(*p).body, T23_);
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 1)], (&stmt));
}
goto LA9_;
LA12_: ;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T25_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T26_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
nimZeroMem((void*)T25_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T26_ = NIM_NIL;
T26_ = percent___jsgen_2012(T25_, 0);
T27_ = NIM_NIL;
T27_ = indentLine__jsgen_97(p, T26_);
add__ropes_159(&(*p).body, T27_);
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 0)], (&stmt));
(*p).extraIndent -= ((NI) 1);
}
LA9_: ;
moveInto__jsgen_1938(p, (&stmt), (&(*r)));
nimZeroMem((void*)T28_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T29_ = NIM_NIL;
T29_ = percent___cgen_7505(T28_, 0);
T30_ = NIM_NIL;
T30_ = indentLine__jsgen_97(p, T29_);
add__ropes_159(&(*p).body, T30_);
i_2 += ((NI) 1);
} LA8: ;
}
}
T31_ = NIM_NIL;
T32_ = NIM_NIL;
T32_ = nsuRepeatChar(125, ((NI) (toClose)));
T31_ = rawNewString((T32_ ? T32_->Sup.len : 0) + 1);
appendString(T31_, T32_);
appendString(T31_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_129));
T33_ = NIM_NIL;
T33_ = rope__ropes_109(T31_);
T34_ = NIM_NIL;
T34_ = indentLine__jsgen_97(p, T33_);
add__ropes_159(&(*p).body, T34_);
}
static N_INLINE(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg*, X5BX5D___jsgen_1858)(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg* s, NI sLen_0, NI i) {
tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg* result;
result = (tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg*)0;
result = (&s[(NI)(sLen_0 - i)]);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1881)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_465), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1895)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_466), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genWhileStmt__jsgen_1839)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w cond;
NI T6_;
tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg* T7_;
tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg* T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* labl;
tyArray__JiWwrsTRC6xqNlGcBthSVA T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T12_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T13_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T14_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T15_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T16_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
NI T18_;
nimZeroMem((void*)(&cond), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
{
NIM_BOOL T3_;
NimStringDesc* argX60gensym353_;
T3_ = (NIM_BOOL)0;
T3_ = isEmptyType__ast_4779((*n).typ);
if (!!(T3_)) goto LA4_;
argX60gensym353_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_464);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym353_, TM__BxLwT0mhrtgTPodf1v3xjg_464);
}
LA4_: ;
genLineDir__jsgen_1818(p, n);
(*p).unique += ((NI) 1);
T6_ = ((*p).blocks ? (*p).blocks->Sup.len : 0);
asgnRef((void**) (&(*p).blocks), (tySequence__8fytVdU59b5aj319cog2ztLw*) setLengthSeqV2(&((*p).blocks)->Sup, (&NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_), ((NI) ((NI)(T6_ + ((NI) 1))))));
T7_ = (tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg*)0;
T7_ = X5BX5D___jsgen_1858((*p).blocks->data, ((*p).blocks ? (*p).blocks->Sup.len : 0), ((NI) 1));
(*T7_).id = ((NI64)-((*p).unique));
T8_ = (tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg*)0;
T8_ = X5BX5D___jsgen_1858((*p).blocks->data, ((*p).blocks ? (*p).blocks->Sup.len : 0), ((NI) 1));
(*T8_).isLoop = NIM_TRUE;
labl = rope__ropes_115(((NI64) ((*p).unique)));
nimZeroMem((void*)T9_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T9_[0] = labl;
T10_ = NIM_NIL;
T10_ = percent___jsgen_1881(T9_, 1);
T11_ = NIM_NIL;
T11_ = indentLine__jsgen_97(p, T10_);
add__ropes_159(&(*p).body, T11_);
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&cond));
(*p).extraIndent -= ((NI) 1);
nimZeroMem((void*)T12_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T12_[0] = cond.res;
T12_[1] = labl;
T13_ = NIM_NIL;
T13_ = percent___jsgen_1895(T12_, 2);
T14_ = NIM_NIL;
T14_ = indentLine__jsgen_97(p, T13_);
add__ropes_159(&(*p).body, T14_);
(*p).extraIndent += ((NI) 1);
genStmt__jsgen_770(p, (*n)._kind_6.sons->data[((NI) 1)]);
(*p).extraIndent -= ((NI) 1);
nimZeroMem((void*)T15_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T15_[0] = labl;
T16_ = NIM_NIL;
T16_ = percent___cgen_7505(T15_, 1);
T17_ = NIM_NIL;
T17_ = indentLine__jsgen_97(p, T16_);
add__ropes_159(&(*p).body, T17_);
T18_ = ((*p).blocks ? (*p).blocks->Sup.len : 0);
asgnRef((void**) (&(*p).blocks), (tySequence__8fytVdU59b5aj319cog2ztLw*) setLengthSeqV2(&((*p).blocks)->Sup, (&NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_), ((NI) ((NI)(T18_ - ((NI) 1))))));
}
N_LIB_PRIVATE N_NIMCALL(void, genVarStmt__jsgen_4260)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* a;
if (!(i_2 < colontmp_)) goto LA3;
i = i_2;
a = (*n)._kind_6.sons->data[i];
{
if (!!(((*a).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 125)))) goto LA6_;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* unpacked;
if (!((*a).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 36))) goto LA10_;
unpacked = lowerTupleUnpacking__lowerings_116((*(*p).module).graph, a, (*(*p).module).Sup.idgen, (*p).prc);
genStmt__jsgen_770(p, unpacked);
}
goto LA8_;
LA10_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* v;
v = (*(*a)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
{
NIM_BOOL T15_;
T15_ = (NIM_BOOL)0;
T15_ = !((((*v).loc.flags &((NU16)1<<((NU)(((tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA) 3))&15U)))!=0));
if (!(T15_)) goto LA16_;
T15_ = !((((*v).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 6))&63U)))!=0));
LA16_: ;
if (!T15_) goto LA17_;
genLineDir__jsgen_1818(p, a);
{
if (!!((((*v).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 28))&63U)))!=0))) goto LA21_;
genVarInit__jsgen_3304(p, v, (*a)._kind_6.sons->data[((NI) 2)]);
}
goto LA19_;
LA21_: ;
{
{
if (!((*v).ast == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL))) goto LA26_;
asgnRef((void**) (&(*v).ast), (*a)._kind_6.sons->data[((NI) 2)]);
}
LA26_: ;
}
LA19_: ;
}
LA17_: ;
}
LA8_: ;
}
LA6_: ;
i_2 += ((NI) 1);
} LA3: ;
}
}
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2154)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_469), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2226)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_474), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genCaseJS__jsgen_2140)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w cond;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w stmt;
NI totalRange;
NIM_BOOL stringSwitch;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T65_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T66_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T67_;
nimZeroMem((void*)(&cond), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&stmt), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
totalRange = ((NI) 0);
genLineDir__jsgen_1818(p, n);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&cond));
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_296);
stringSwitch = ((*T1_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28));
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T8_;
if (!stringSwitch) goto LA4_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_373));
nimZeroMem((void*)T6_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T6_[0] = rdLoc__jsgen_188((&cond));
T7_ = NIM_NIL;
T7_ = percent___jsgen_2154(T6_, 1);
T8_ = NIM_NIL;
T8_ = indentLine__jsgen_97(p, T7_);
add__ropes_159(&(*p).body, T8_);
}
goto LA2_;
LA4_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
nimZeroMem((void*)T10_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T10_[0] = rdLoc__jsgen_188((&cond));
T11_ = NIM_NIL;
T11_ = percent___cgen_13684(T10_, 1);
T12_ = NIM_NIL;
T12_ = indentLine__jsgen_97(p, T11_);
add__ropes_159(&(*p).body, T12_);
}
LA2_: ;
{
NIM_BOOL T15_;
T15_ = (NIM_BOOL)0;
T15_ = isEmptyType__ast_4779((*n).typ);
if (!!(T15_)) goto LA16_;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
}
LA16_: ;
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 1);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
if (!(i_2 < colontmp_)) goto LA20;
i = i_2;
it = (*n)._kind_6.sons->data[i];
switch ((*it).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 85):
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T53_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T54_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T55_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T56_;
{
NI j;
NI colontmp__2;
NI T23_;
NI i_3;
j = (NI)0;
colontmp__2 = (NI)0;
T23_ = (NI)0;
T23_ = len__ast_3198(it);
colontmp__2 = (NI)(T23_ - ((NI) 1));
i_3 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* e;
if (!(i_3 < colontmp__2)) goto LA25;
j = i_3;
e = (*it)._kind_6.sons->data[j];
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* v;
if (!((*e).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 44))) goto LA28_;
v = copyNode__ast_4336((*e)._kind_6.sons->data[((NI) 0)]);
totalRange += ((NI) ((NI64)((*(*e)._kind_6.sons->data[((NI) 1)])._kind_1.intVal - (*v)._kind_1.intVal)));
{
if (!(((NI) 65535) < totalRange)) goto LA32_;
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_470), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 0), TM__BxLwT0mhrtgTPodf1v3xjg_471, NIM_FALSE);
}
LA32_: ;
{
while (1) {
tyArray__JiWwrsTRC6xqNlGcBthSVA T36_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T37_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T38_;
if (!((*v)._kind_1.intVal <= (*(*e)._kind_6.sons->data[((NI) 1)])._kind_1.intVal)) goto LA35;
gen__jsgen_766(p, v, (&cond));
nimZeroMem((void*)T36_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T36_[0] = rdLoc__jsgen_188((&cond));
T37_ = NIM_NIL;
T37_ = percent___cgen_15312(T36_, 1);
T38_ = NIM_NIL;
T38_ = indentLine__jsgen_97(p, T37_);
add__ropes_159(&(*p).body, T38_);
(*v)._kind_1.intVal += ((NI) 1);
} LA35: ;
}
}
goto LA26_;
LA28_: ;
{
{
if (!stringSwitch) goto LA42_;
switch ((*e).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 20) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 22):
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T45_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T46_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T47_;
nimZeroMem((void*)T45_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T45_[0] = makeJSString__jsgen_378((*e)._kind_3.strVal, NIM_FALSE);
T46_ = NIM_NIL;
T46_ = percent___cgen_15312(T45_, 1);
T47_ = NIM_NIL;
T47_ = indentLine__jsgen_97(p, T46_);
add__ropes_159(&(*p).body, T47_);
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*e).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_472), TM__BxLwT0mhrtgTPodf1v3xjg_473);
}
break;
}
}
goto LA40_;
LA42_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T50_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T51_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T52_;
gen__jsgen_766(p, e, (&cond));
nimZeroMem((void*)T50_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T50_[0] = rdLoc__jsgen_188((&cond));
T51_ = NIM_NIL;
T51_ = percent___cgen_15312(T50_, 1);
T52_ = NIM_NIL;
T52_ = indentLine__jsgen_97(p, T51_);
add__ropes_159(&(*p).body, T52_);
}
LA40_: ;
}
LA26_: ;
i_3 += ((NI) 1);
} LA25: ;
}
}
(*p).extraIndent += ((NI) 1);
T53_ = NIM_NIL;
T53_ = lastSon__ast_4832(it);
gen__jsgen_766(p, T53_, (&stmt));
moveInto__jsgen_1938(p, (&stmt), (&(*r)));
nimZeroMem((void*)T54_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T55_ = NIM_NIL;
T55_ = percent___cgen_7416(T54_, 0);
T56_ = NIM_NIL;
T56_ = indentLine__jsgen_97(p, T55_);
add__ropes_159(&(*p).body, T56_);
(*p).extraIndent -= ((NI) 1);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 88):
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T58_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T59_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T60_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T61_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T62_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T63_;
nimZeroMem((void*)T58_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T59_ = NIM_NIL;
T59_ = percent___jsgen_2226(T58_, 0);
T60_ = NIM_NIL;
T60_ = indentLine__jsgen_97(p, T59_);
add__ropes_159(&(*p).body, T60_);
(*p).extraIndent += ((NI) 1);
gen__jsgen_766(p, (*it)._kind_6.sons->data[((NI) 0)], (&stmt));
moveInto__jsgen_1938(p, (&stmt), (&(*r)));
nimZeroMem((void*)T61_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T62_ = NIM_NIL;
T62_ = percent___cgen_7416(T61_, 0);
T63_ = NIM_NIL;
T63_ = indentLine__jsgen_97(p, T62_);
add__ropes_159(&(*p).body, T63_);
(*p).extraIndent -= ((NI) 1);
}
break;
default:
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*it).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_475), TM__BxLwT0mhrtgTPodf1v3xjg_476);
}
break;
}
i_2 += ((NI) 1);
} LA20: ;
}
}
nimZeroMem((void*)T65_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T66_ = NIM_NIL;
T66_ = percent___cgen_7505(T65_, 0);
T67_ = NIM_NIL;
T67_ = indentLine__jsgen_97(p, T66_);
add__ropes_159(&(*p).body, T67_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_5816)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_479), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genReturnStmt__jsgen_5803)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyArray__qTjAvTvKF9anytN1At69aJMQ T10_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T11_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T12_;
{
if (!((*p).procDef == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL))) goto LA3_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_477), TM__BxLwT0mhrtgTPodf1v3xjg_478);
}
LA3_: ;
(*p).beforeRetNeeded = NIM_TRUE;
{
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1)))) goto LA7_;
genStmt__jsgen_770(p, (*n)._kind_6.sons->data[((NI) 0)]);
}
goto LA5_;
LA7_: ;
{
genLineDir__jsgen_1818(p, n);
}
LA5_: ;
nimZeroMem((void*)T10_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T11_ = NIM_NIL;
T11_ = percent___jsgen_5816(T10_, 0);
T12_ = NIM_NIL;
T12_ = indentLine__jsgen_97(p, T11_);
add__ropes_159(&(*p).body, T12_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2325)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_482), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genBreakStmt__jsgen_2292)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NI idx;
tyArray__JiWwrsTRC6xqNlGcBthSVA T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T19_;
idx = (NI)0;
genLineDir__jsgen_1818(p, n);
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* sym;
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1)))) goto LA3_;
sym = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
idx = (NI)((*sym).position - ((NI) 1));
}
goto LA1_;
LA3_: ;
{
NI T6_;
T6_ = ((*p).blocks ? (*p).blocks->Sup.len : 0);
idx = (NI)(T6_ - ((NI) 1));
{
while (1) {
NIM_BOOL T9_;
T9_ = (NIM_BOOL)0;
T9_ = (((NI) 0) <= idx);
if (!(T9_)) goto LA10_;
T9_ = !((*p).blocks->data[idx].isLoop);
LA10_: ;
if (!T9_) goto LA8;
idx -= ((NI) 1);
} LA8: ;
}
{
NIM_BOOL T13_;
T13_ = (NIM_BOOL)0;
T13_ = (idx < ((NI) 0));
if (T13_) goto LA14_;
T13_ = !((*p).blocks->data[idx].isLoop);
LA14_: ;
if (!T13_) goto LA15_;
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_480), TM__BxLwT0mhrtgTPodf1v3xjg_481);
}
LA15_: ;
}
LA1_: ;
(*p).blocks->data[idx].id = ((*p).blocks->data[idx].id > 0? ((*p).blocks->data[idx].id) : -((*p).blocks->data[idx].id));
nimZeroMem((void*)T17_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T17_[0] = rope__ropes_115(((NI64) ((*p).blocks->data[idx].id)));
T18_ = NIM_NIL;
T18_ = percent___jsgen_2325(T17_, 1);
T19_ = NIM_NIL;
T19_ = indentLine__jsgen_97(p, T18_);
add__ropes_159(&(*p).body, T19_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2539)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_485), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2561)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_486), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2566)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_487), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2584)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_488), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2593)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_489), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2610)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_491), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, addQuoted__jsgen_2669)(NimStringDesc** s, tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA x) {
unsureAsgnRef((void**) (&(*s)), resizeString((*s), (reprEnum((NI)x, (&NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_)) ? reprEnum((NI)x, (&NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_))->Sup.len : 0) + 0));
appendString((*s), reprEnum((NI)x, (&NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_)));
}
N_LIB_PRIVATE N_NIMCALL(NimStringDesc*, dollar___jsgen_2635)(tyTuple__QVkyTCL0msoEdWvhK6TYrw x) {
NimStringDesc* result;
NI count;
result = NIM_NIL;
result = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_117));
count = ((NI) 0);
{
if (!(((NI) 0) < count)) goto LA3_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA3_: ;
count += ((NI) 1);
addQuoted__pureZos_431((&result), x.Field0);
{
if (!(((NI) 0) < count)) goto LA7_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA7_: ;
count += ((NI) 1);
addQuoted__jsgen_2669((&result), x.Field1);
{
if (!(((NI) 0) < count)) goto LA11_;
result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_118));
}
LA11_: ;
count += ((NI) 1);
addQuoted__jsgen_2669((&result), x.Field2);
{
if (!(count == ((NI) 1))) goto LA15_;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_413));
}
LA15_: ;
result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_119));
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2692)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_497), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genAsgnAux__jsgen_2511)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* x, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* y, NIM_BOOL noCopyNeeded) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w b;
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA xtyp;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
nimZeroMem((void*)(&b), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
xtyp = mapType__jsgen_304(p, (*x).typ);
{
NIM_BOOL T3_;
NIM_BOOL T4_;
NI T6_;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T8_;
T3_ = (NIM_BOOL)0;
T4_ = (NIM_BOOL)0;
T4_ = ((*x).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 42));
if (!(T4_)) goto LA5_;
T6_ = (NI)0;
T6_ = len__ast_3198(x);
T4_ = (((NI) 2) <= T6_);
LA5_: ;
T3_ = T4_;
if (!(T3_)) goto LA7_;
T8_ = NIM_NIL;
T8_ = skipTypes__ast_3735((*(*x)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
T3_ = ((*T8_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 29));
LA7_: ;
if (!T3_) goto LA9_;
liMessage__msgs_1118((*(*p).module).config, (*x).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_483), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 0), TM__BxLwT0mhrtgTPodf1v3xjg_484, NIM_FALSE);
}
LA9_: ;
gen__jsgen_766(p, x, (&a));
genLineDir__jsgen_1818(p, y);
gen__jsgen_766(p, y, (&b));
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T13_;
T13_ = NIM_NIL;
T13_ = skipTypes__ast_3735((*x).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
if (!((*T13_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24) || (*T13_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28))) goto LA14_;
xtyp = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 4);
}
LA14_: ;
switch (xtyp) {
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 4):
{
{
NIM_BOOL T19_;
NIM_BOOL T20_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T25_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T26_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
T19_ = (NIM_BOOL)0;
T20_ = (NIM_BOOL)0;
T20_ = needsNoCopy__jsgen_2483(p, y);
if (!(T20_)) goto LA21_;
T20_ = needsNoCopy__jsgen_2483(p, x);
LA21_: ;
T19_ = T20_;
if (T19_) goto LA22_;
T19_ = noCopyNeeded;
LA22_: ;
if (!T19_) goto LA23_;
nimZeroMem((void*)T25_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T25_[0] = rdLoc__jsgen_188((&a));
T25_[1] = rdLoc__jsgen_188((&b));
T26_ = NIM_NIL;
T26_ = percent___jsgen_1950(T25_, 2);
T27_ = NIM_NIL;
T27_ = indentLine__jsgen_97(p, T26_);
add__ropes_159(&(*p).body, T27_);
}
goto LA17_;
LA23_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T31_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
nimZeroMem((void*)T29_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T29_[0] = rdLoc__jsgen_188((&a));
T29_[1] = b.res;
T29_[2] = genTypeInfo__jsgen_385(p, (*y).typ);
T30_ = NIM_NIL;
T30_ = percent___jsgen_2539(T29_, 3);
T31_ = NIM_NIL;
T31_ = indentLine__jsgen_97(p, T30_);
add__ropes_159(&(*p).body, T31_);
}
LA17_: ;
}
break;
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 8):
{
{
NIM_BOOL T35_;
NIM_BOOL T36_;
NIM_BOOL T38_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T43_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T44_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T45_;
T35_ = (NIM_BOOL)0;
T36_ = (NIM_BOOL)0;
T36_ = ((*(*x).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23));
if (T36_) goto LA37_;
T38_ = (NIM_BOOL)0;
T38_ = needsNoCopy__jsgen_2483(p, y);
if (!(T38_)) goto LA39_;
T38_ = needsNoCopy__jsgen_2483(p, x);
LA39_: ;
T36_ = T38_;
LA37_: ;
T35_ = T36_;
if (T35_) goto LA40_;
T35_ = noCopyNeeded;
LA40_: ;
if (!T35_) goto LA41_;
nimZeroMem((void*)T43_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T43_[0] = rdLoc__jsgen_188((&a));
T43_[1] = rdLoc__jsgen_188((&b));
T44_ = NIM_NIL;
T44_ = percent___jsgen_1950(T43_, 2);
T45_ = NIM_NIL;
T45_ = indentLine__jsgen_97(p, T44_);
add__ropes_159(&(*p).body, T45_);
}
goto LA33_;
LA41_: ;
{
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_141));
{
NIM_BOOL T49_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T53_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T54_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T55_;
T49_ = (NIM_BOOL)0;
T49_ = ((*x).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 65) || (*x).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 47));
if (!(T49_)) goto LA50_;
T49_ = ((*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 27) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 29) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 30) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 31) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 28) || (*(*x)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32));
LA50_: ;
if (!T49_) goto LA51_;
nimZeroMem((void*)T53_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T53_[0] = a.res;
T53_[1] = b.res;
T53_[2] = genTypeInfo__jsgen_385(p, (*x).typ);
T54_ = NIM_NIL;
T54_ = percent___jsgen_2561(T53_, 3);
T55_ = NIM_NIL;
T55_ = indentLine__jsgen_97(p, T54_);
add__ropes_159(&(*p).body, T55_);
}
goto LA47_;
LA51_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T57_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T58_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T59_;
nimZeroMem((void*)T57_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T57_[0] = a.res;
T57_[1] = b.res;
T57_[2] = genTypeInfo__jsgen_385(p, (*x).typ);
T58_ = NIM_NIL;
T58_ = percent___jsgen_2566(T57_, 3);
T59_ = NIM_NIL;
T59_ = indentLine__jsgen_97(p, T58_);
add__ropes_159(&(*p).body, T59_);
}
LA47_: ;
}
LA33_: ;
}
break;
case ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9):
{
{
NIM_BOOL T63_;
T63_ = (NIM_BOOL)0;
T63_ = !((a.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)));
if (T63_) goto LA64_;
T63_ = !((b.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9)));
LA64_: ;
if (!T63_) goto LA65_;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmp;
tyArray__f7nG5LD47BH5K9c6mASit3g T71_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T72_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T73_;
if (!((*y).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 27))) goto LA69_;
tmp = getTemp__jsgen_838(p, NIM_FALSE);
nimZeroMem((void*)T71_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T71_[0] = tmp;
T71_[1] = a.address;
T71_[2] = a.res;
T71_[3] = rdLoc__jsgen_188((&b));
T72_ = NIM_NIL;
T72_ = percent___jsgen_2584(T71_, 4);
T73_ = NIM_NIL;
T73_ = indentLine__jsgen_97(p, T72_);
add__ropes_159(&(*p).body, T73_);
}
goto LA67_;
LA69_: ;
{
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T77_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T78_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T79_;
if (!(b.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA75_;
nimZeroMem((void*)T77_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T77_[0] = a.res;
T77_[1] = b.address;
T77_[2] = b.res;
T78_ = NIM_NIL;
T78_ = percent___jsgen_2593(T77_, 3);
T79_ = NIM_NIL;
T79_ = indentLine__jsgen_97(p, T78_);
add__ropes_159(&(*p).body, T79_);
}
goto LA67_;
LA75_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T87_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T88_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T89_;
if (!(b.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0))) goto LA81_;
{
NimStringDesc* argX60gensym523_;
if (!!((b.address == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA85_;
argX60gensym523_ = toFileLineCol__msgs_615(TM__BxLwT0mhrtgTPodf1v3xjg_490);
internalErrorImpl__msgs_1431((*(*p).module).config, unknownLineInfo__lineinfos_280, argX60gensym523_, TM__BxLwT0mhrtgTPodf1v3xjg_490);
}
LA85_: ;
nimZeroMem((void*)T87_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T87_[0] = a.address;
T87_[1] = b.res;
T88_ = NIM_NIL;
T88_ = percent___jsgen_2610(T87_, 2);
T89_ = NIM_NIL;
T89_ = indentLine__jsgen_97(p, T88_);
add__ropes_159(&(*p).body, T89_);
}
goto LA67_;
LA81_: ;
{
NIM_BOOL T91_;
tyArray__wqYjTJU9ab2ZgEFMaQc3vNA T95_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T96_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T97_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T98_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T99_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T100_;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T101_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T102_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T103_;
T91_ = (NIM_BOOL)0;
T91_ = ((*(*x).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 23));
if (!(T91_)) goto LA92_;
T91_ = ((*(*y).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 21));
LA92_: ;
if (!T91_) goto LA93_;
nimZeroMem((void*)T95_, sizeof(tyArray__wqYjTJU9ab2ZgEFMaQc3vNA));
T95_[0] = a.res;
T95_[1] = b.address;
T95_[2] = b.res;
T96_ = NIM_NIL;
T96_ = percent___jsgen_2593(T95_, 3);
T97_ = NIM_NIL;
T97_ = indentLine__jsgen_97(p, T96_);
add__ropes_159(&(*p).body, T97_);
nimZeroMem((void*)T98_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T98_[0] = a.address;
T98_[1] = b.res;
T99_ = NIM_NIL;
T99_ = percent___jsgen_1950(T98_, 2);
T100_ = NIM_NIL;
T100_ = indentLine__jsgen_97(p, T99_);
add__ropes_159(&(*p).body, T100_);
nimZeroMem((void*)T101_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T101_[0] = rdLoc__jsgen_188((&a));
T101_[1] = rdLoc__jsgen_188((&b));
T102_ = NIM_NIL;
T102_ = percent___jsgen_1950(T101_, 2);
T103_ = NIM_NIL;
T103_ = indentLine__jsgen_97(p, T102_);
add__ropes_159(&(*p).body, T103_);
}
goto LA67_;
LA93_: ;
{
tyTuple__QVkyTCL0msoEdWvhK6TYrw T105_;
NimStringDesc* T106_;
nimZeroMem((void*)(&T105_), sizeof(tyTuple__QVkyTCL0msoEdWvhK6TYrw));
T105_.Field0 = copyString(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_495));
T105_.Field1 = b.typ;
T105_.Field2 = a.typ;
T106_ = NIM_NIL;
T106_ = dollar___jsgen_2635(T105_);
internalErrorImpl__msgs_1431((*(*p).module).config, (*x).info, T106_, TM__BxLwT0mhrtgTPodf1v3xjg_496);
}
LA67_: ;
}
goto LA61_;
LA65_: ;
{
tyArray__f7nG5LD47BH5K9c6mASit3g T108_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T109_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T110_;
nimZeroMem((void*)T108_, sizeof(tyArray__f7nG5LD47BH5K9c6mASit3g));
T108_[0] = a.address;
T108_[1] = b.address;
T108_[2] = a.res;
T108_[3] = b.res;
T109_ = NIM_NIL;
T109_ = percent___jsgen_2692(T108_, 4);
T110_ = NIM_NIL;
T110_ = indentLine__jsgen_97(p, T109_);
add__ropes_159(&(*p).body, T110_);
}
LA61_: ;
}
break;
default:
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T112_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T113_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T114_;
nimZeroMem((void*)T112_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T112_[0] = rdLoc__jsgen_188((&a));
T112_[1] = rdLoc__jsgen_188((&b));
T113_ = NIM_NIL;
T113_ = percent___jsgen_1950(T112_, 2);
T114_ = NIM_NIL;
T114_ = indentLine__jsgen_97(p, T113_);
add__ropes_159(&(*p).body, T114_);
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(void, genAsgn__jsgen_2701)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
genAsgnAux__jsgen_2511(p, (*n)._kind_6.sons->data[((NI) 0)], (*n)._kind_6.sons->data[((NI) 1)], NIM_FALSE);
}
N_LIB_PRIVATE N_NIMCALL(void, genFastAsgn__jsgen_2706)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
NIM_BOOL noCopy;
tyObject_TType__facALICuu8zUj0hjvbTLFg* T1_;
T1_ = NIM_NIL;
T1_ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_97);
noCopy = ((*T1_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 24) || (*T1_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28));
genAsgnAux__jsgen_2511(p, (*n)._kind_6.sons->data[((NI) 0)], (*n)._kind_6.sons->data[((NI) 1)], noCopy);
}
N_LIB_PRIVATE N_NIMCALL(void, genAsmOrEmitStmt__jsgen_2330)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T1_;
genLineDir__jsgen_1818(p, n);
T1_ = NIM_NIL;
T1_ = indentLine__jsgen_97(p, ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
add__ropes_159(&(*p).body, T1_);
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(n);
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
if (!(i_2 < colontmp_)) goto LA4;
i = i_2;
it = (*n)._kind_6.sons->data[i];
switch ((*it).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 20) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 22):
{
add__ropes_162(&(*p).body, (*it)._kind_3.strVal);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* v;
v = (*it)._kind_4.sym;
{
if (!NIM_FALSE) goto LA9_;
}
goto LA7_;
LA9_: ;
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w r;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
nimZeroMem((void*)(&r), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, it, (&r));
{
if (!((*(*it).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 26))) goto LA14_;
r.res = r.address;
r.address = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
r.typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
goto LA12_;
LA14_: ;
{
tyArray__mrugoXXRZUEeG9bEXo9auBKw T19_;
if (!(r.typ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA17_;
nimZeroMem((void*)T19_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T19_[0] = r.address;
T19_[1] = r.res;
r.res = percent___cgen_6775(T19_, 2);
r.address = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
r.typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
}
goto LA12_;
LA17_: ;
LA12_: ;
T20_ = NIM_NIL;
T20_ = rdLoc__jsgen_188((&r));
add__ropes_159(&(*p).body, T20_);
}
LA7_: ;
}
break;
default:
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w r_2;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T22_;
nimZeroMem((void*)(&r_2), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, it, (&r_2));
T22_ = NIM_NIL;
T22_ = rdLoc__jsgen_188((&r_2));
add__ropes_159(&(*p).body, T22_);
}
break;
}
i_2 += ((NI) 1);
} LA4: ;
}
}
add__ropes_162(&(*p).body, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_129));
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1982)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_502), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1990)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_503), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_1995)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_504), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2057)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_509), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2062)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_510), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2067)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_512), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2076)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_513), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2095)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_517), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genTry__jsgen_1959)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
NI i;
NIM_BOOL catchBranchesExist;
NIM_BOOL T6_;
NI T7_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* tmpFramePtr;
tyArray__qTjAvTvKF9anytN1At69aJMQ T19_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
NIM_BOOL generalCatchBranchExists;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T124_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T125_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T126_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T127_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T128_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T136_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T137_;
genLineDir__jsgen_1818(p, n);
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = isEmptyType__ast_4779((*n).typ);
if (!!(T3_)) goto LA4_;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 2);
unsureAsgnRef((void**) (&(*r).res), getTemp__jsgen_838(p, NIM_TRUE));
}
LA4_: ;
(*p).unique += ((NI) 1);
i = ((NI) 1);
T6_ = (NIM_BOOL)0;
T7_ = (NI)0;
T7_ = len__ast_3198(n);
T6_ = (((NI) 1) < T7_);
if (!(T6_)) goto LA8_;
T6_ = ((*(*n)._kind_6.sons->data[i]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 87));
LA8_: ;
catchBranchesExist = T6_;
{
if (!catchBranchesExist) goto LA11_;
add__ropes_162(&(*p).body, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_499));
}
LA11_: ;
tmpFramePtr = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_500));
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T17_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
if (!!((((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 17))&31U)))!=0))) goto LA15_;
tmpFramePtr = getTemp__jsgen_838(p, NIM_TRUE);
T17_ = NIM_NIL;
T17_ = amp___ropes_140(tmpFramePtr, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_501));
T18_ = NIM_NIL;
T18_ = indentLine__jsgen_97(p, T17_);
add__ropes_159(&(*p).body, T18_);
}
LA15_: ;
nimZeroMem((void*)T19_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T20_ = NIM_NIL;
T20_ = percent___jsgen_1982(T19_, 0);
T21_ = NIM_NIL;
T21_ = indentLine__jsgen_97(p, T20_);
add__ropes_159(&(*p).body, T21_);
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&a));
moveInto__jsgen_1938(p, (&a), (&(*r)));
generalCatchBranchExists = NIM_FALSE;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T26_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T27_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T28_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T29_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
if (!catchBranchesExist) goto LA24_;
nimZeroMem((void*)T26_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T27_ = NIM_NIL;
T27_ = percent___jsgen_1990(T26_, 0);
add__ropes_159(&(*p).body, T27_);
nimZeroMem((void*)T28_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T28_[0] = tmpFramePtr;
T29_ = NIM_NIL;
T29_ = percent___jsgen_1995(T28_, 1);
T30_ = NIM_NIL;
T30_ = indentLine__jsgen_97(p, T29_);
add__ropes_159(&(*p).body, T30_);
}
LA24_: ;
{
while (1) {
NIM_BOOL T33_;
NI T34_;
T33_ = (NIM_BOOL)0;
T34_ = (NI)0;
T34_ = len__ast_3198(n);
T33_ = (i < T34_);
if (!(T33_)) goto LA35_;
T33_ = ((*(*n)._kind_6.sons->data[i]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 87));
LA35_: ;
if (!T33_) goto LA32;
{
NI T38_;
T38_ = (NI)0;
T38_ = len__ast_3198((*n)._kind_6.sons->data[i]);
if (!(T38_ == ((NI) 1))) goto LA39_;
generalCatchBranchExists = NIM_TRUE;
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T45_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T46_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T47_;
if (!(((NI) 1) < i)) goto LA43_;
nimZeroMem((void*)T45_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T46_ = NIM_NIL;
T46_ = percent___jsgen_2012(T45_, 0);
T47_ = NIM_NIL;
T47_ = indentLine__jsgen_97(p, T46_);
add__ropes_159(&(*p).body, T47_);
}
LA43_: ;
gen__jsgen_766(p, (*(*n)._kind_6.sons->data[i])._kind_6.sons->data[((NI) 0)], (&a));
moveInto__jsgen_1938(p, (&a), (&(*r)));
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T52_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T53_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T54_;
if (!(((NI) 1) < i)) goto LA50_;
nimZeroMem((void*)T52_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T53_ = NIM_NIL;
T53_ = percent___cgen_7505(T52_, 0);
T54_ = NIM_NIL;
T54_ = indentLine__jsgen_97(p, T53_);
add__ropes_159(&(*p).body, T54_);
}
LA50_: ;
}
goto LA36_;
LA39_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* orExpr;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* excAlias;
tyArray__JiWwrsTRC6xqNlGcBthSVA T93_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T94_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T95_;
NI T103_;
tyArray__qTjAvTvKF9anytN1At69aJMQ T104_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T105_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T106_;
orExpr = ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL);
excAlias = ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL);
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_367));
{
NI j;
NI colontmp_;
NI T57_;
NI i_2;
j = (NI)0;
colontmp_ = (NI)0;
T57_ = (NI)0;
T57_ = len__ast_3198((*n)._kind_6.sons->data[i]);
colontmp_ = (NI)(T57_ - ((NI) 1));
i_2 = ((NI) 0);
{
while (1) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* throwObj;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* it;
if (!(i_2 < colontmp_)) goto LA59;
j = i_2;
throwObj = NIM_NIL;
it = (*(*n)._kind_6.sons->data[i])._kind_6.sons->data[j];
{
NIM_BOOL T62_;
T62_ = (NIM_BOOL)0;
T62_ = isInfixAs__ast_4935(it);
if (!T62_) goto LA63_;
throwObj = (*it)._kind_6.sons->data[((NI) 1)];
excAlias = (*it)._kind_6.sons->data[((NI) 2)];
{
if (!!((orExpr == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA67_;
failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_505));
}
LA67_: ;
}
goto LA60_;
LA63_: ;
{
if (!((*it).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 4))) goto LA70_;
throwObj = it;
}
goto LA60_;
LA70_: ;
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_506), TM__BxLwT0mhrtgTPodf1v3xjg_507);
}
LA60_: ;
{
if (!!((orExpr == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA75_;
add__ropes_162(&orExpr, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_508));
}
LA75_: ;
{
NIM_BOOL T79_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T82_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T83_;
T79_ = (NIM_BOOL)0;
T79_ = isImportedException__ast_4904((*throwObj).typ, (*(*p).module).config);
if (!T79_) goto LA80_;
nimZeroMem((void*)T82_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T82_[0] = (*(*(*throwObj).typ).sym).loc.r;
T83_ = NIM_NIL;
T83_ = percent___jsgen_2057(T82_, 1);
add__ropes_159(&orExpr, T83_);
}
goto LA77_;
LA80_: ;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T85_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T86_;
nimZeroMem((void*)T85_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T85_[0] = genTypeInfo__jsgen_385(p, (*throwObj).typ);
T86_ = NIM_NIL;
T86_ = percent___jsgen_2062(T85_, 1);
add__ropes_159(&orExpr, T86_);
}
LA77_: ;
i_2 += ((NI) 1);
} LA59: ;
}
}
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T91_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T92_;
if (!(((NI) 1) < i)) goto LA89_;
T91_ = NIM_NIL;
T91_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_511));
T92_ = NIM_NIL;
T92_ = indentLine__jsgen_97(p, T91_);
add__ropes_159(&(*p).body, T92_);
}
LA89_: ;
nimZeroMem((void*)T93_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T93_[0] = orExpr;
T94_ = NIM_NIL;
T94_ = percent___jsgen_2067(T93_, 1);
T95_ = NIM_NIL;
T95_ = indentLine__jsgen_97(p, T94_);
add__ropes_159(&(*p).body, T95_);
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T100_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T101_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T102_;
if (!!((excAlias == ((tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*) NIM_NIL)))) goto LA98_;
asgnRef((void**) (&(*(*excAlias)._kind_4.sym).loc.r), mangleName__jsgen_308((*p).module, (*excAlias)._kind_4.sym));
nimZeroMem((void*)T100_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T100_[0] = (*(*excAlias)._kind_4.sym).loc.r;
T101_ = NIM_NIL;
T101_ = percent___jsgen_2076(T100_, 1);
T102_ = NIM_NIL;
T102_ = indentLine__jsgen_97(p, T101_);
add__ropes_159(&(*p).body, T102_);
}
LA98_: ;
T103_ = (NI)0;
T103_ = len__ast_3198((*n)._kind_6.sons->data[i]);
gen__jsgen_766(p, (*(*n)._kind_6.sons->data[i])._kind_6.sons->data[(NI)(T103_ - ((NI) 1))], (&a));
moveInto__jsgen_1938(p, (&a), (&(*r)));
nimZeroMem((void*)T104_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T105_ = NIM_NIL;
T105_ = percent___cgen_7505(T104_, 0);
T106_ = NIM_NIL;
T106_ = indentLine__jsgen_97(p, T105_);
add__ropes_159(&(*p).body, T106_);
}
LA36_: ;
i += ((NI) 1);
} LA32: ;
}
{
tyArray__qTjAvTvKF9anytN1At69aJMQ T121_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T122_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T123_;
if (!catchBranchesExist) goto LA109_;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T115_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T116_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T117_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T118_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T119_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T120_;
if (!!(generalCatchBranchExists)) goto LA113_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_514));
T115_ = NIM_NIL;
T115_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_515));
T116_ = NIM_NIL;
T116_ = indentLine__jsgen_97(p, T115_);
add__ropes_159(&(*p).body, T116_);
T117_ = NIM_NIL;
T117_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_516));
T118_ = NIM_NIL;
T118_ = indentLine__jsgen_97(p, T117_);
add__ropes_159(&(*p).body, T118_);
T119_ = NIM_NIL;
T119_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_25));
T120_ = NIM_NIL;
T120_ = indentLine__jsgen_97(p, T119_);
add__ropes_159(&(*p).body, T120_);
}
LA113_: ;
nimZeroMem((void*)T121_, sizeof(tyArray__qTjAvTvKF9anytN1At69aJMQ));
T122_ = NIM_NIL;
T122_ = percent___jsgen_2095(T121_, 0);
T123_ = NIM_NIL;
T123_ = indentLine__jsgen_97(p, T122_);
add__ropes_159(&(*p).body, T123_);
}
LA109_: ;
T124_ = NIM_NIL;
T124_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_518));
T125_ = NIM_NIL;
T125_ = indentLine__jsgen_97(p, T124_);
add__ropes_159(&(*p).body, T125_);
nimZeroMem((void*)T126_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T126_[0] = tmpFramePtr;
T127_ = NIM_NIL;
T127_ = percent___jsgen_1995(T126_, 1);
T128_ = NIM_NIL;
T128_ = indentLine__jsgen_97(p, T127_);
add__ropes_159(&(*p).body, T128_);
{
NIM_BOOL T131_;
NI T132_;
T131_ = (NIM_BOOL)0;
T132_ = (NI)0;
T132_ = len__ast_3198(n);
T131_ = (i < T132_);
if (!(T131_)) goto LA133_;
T131_ = ((*(*n)._kind_6.sons->data[i]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 107));
LA133_: ;
if (!T131_) goto LA134_;
genStmt__jsgen_770(p, (*(*n)._kind_6.sons->data[i])._kind_6.sons->data[((NI) 0)]);
}
LA134_: ;
T136_ = NIM_NIL;
T136_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_25));
T137_ = NIM_NIL;
T137_ = indentLine__jsgen_97(p, T136_);
add__ropes_159(&(*p).body, T137_);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_2135)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_520), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genRaiseStmt__jsgen_2123)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
{
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w a;
tyObject_TType__facALICuu8zUj0hjvbTLFg* typ;
tyArray__mrugoXXRZUEeG9bEXo9auBKw T5_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1)))) goto LA3_;
nimZeroMem((void*)(&a), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], (&a));
typ = skipTypes__ast_3735((*(*n)._kind_6.sons->data[((NI) 0)]).typ, TM__BxLwT0mhrtgTPodf1v3xjg_334);
genLineDir__jsgen_1818(p, n);
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_519));
nimZeroMem((void*)T5_, sizeof(tyArray__mrugoXXRZUEeG9bEXo9auBKw));
T5_[0] = rdLoc__jsgen_188((&a));
T5_[1] = makeJSString__jsgen_378((*(*(*typ).sym).name).s, NIM_TRUE);
T6_ = NIM_NIL;
T6_ = percent___jsgen_2135(T5_, 2);
T7_ = NIM_NIL;
T7_ = indentLine__jsgen_97(p, T6_);
add__ropes_159(&(*p).body, T7_);
}
goto LA1_;
LA3_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T10_;
genLineDir__jsgen_1818(p, n);
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_514));
T9_ = NIM_NIL;
T9_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_521));
T10_ = NIM_NIL;
T10_ = indentLine__jsgen_97(p, T9_);
add__ropes_159(&(*p).body, T10_);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, genPragma__jsgen_6039)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw** it;
tySequence__ehmV9bTklH2Gt9cXHV9c0HLeQ* colontmp_;
NI i;
NI L;
NI T2_;
it = (tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw**)0;
colontmp_ = NIM_NIL;
colontmp_ = (*n)._kind_6.sons;
i = ((NI) 0);
T2_ = (colontmp_ ? colontmp_->Sup.len : 0);
L = T2_;
{
while (1) {
tyEnum_TSpecialWord__ycbpMCRV6Cd2eBh3X9biEiw T5_;
if (!(i < L)) goto LA4;
it = &colontmp_->data[i];
T5_ = (tyEnum_TSpecialWord__ycbpMCRV6Cd2eBh3X9biEiw)0;
T5_ = whichPragma__trees_244((*it));
switch (T5_) {
case ((tyEnum_TSpecialWord__ycbpMCRV6Cd2eBh3X9biEiw) 214):
{
genAsmOrEmitStmt__jsgen_2330(p, (*(*it))._kind_6.sons->data[((NI) 1)]);
}
break;
default:
{
}
break;
}
i += ((NI) 1);
} LA4: ;
}
}
}
N_LIB_PRIVATE N_NIMCALL(void, gen__jsgen_766)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w* r) {
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 0);
{
if (!!(((*r).kind == ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 3)))) goto LA3_;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 0);
}
LA3_: ;
unsureAsgnRef((void**) (&(*r).res), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
switch ((*n).kind) {
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3):
{
genSym__jsgen_3308(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 5) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 15):
{
{
if (!((*(*n).typ).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 1))) goto LA9_;
{
if (!((*n)._kind_1.intVal == IL64(0))) goto LA13_;
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_207)));
}
goto LA11_;
LA13_: ;
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_208)));
}
LA11_: ;
}
goto LA7_;
LA9_: ;
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_115((*n)._kind_1.intVal));
}
LA7_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 23):
{
{
NIM_BOOL T20_;
T20_ = (NIM_BOOL)0;
T20_ = isEmptyType__ast_4779((*n).typ);
if (!T20_) goto LA21_;
}
goto LA18_;
LA21_: ;
{
tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA T24_;
T24_ = (tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA)0;
T24_ = mapType__jsgen_304(p, (*n).typ);
if (!(T24_ == ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9))) goto LA25_;
(*r).typ = ((tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA) 9);
unsureAsgnRef((void**) (&(*r).address), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_209)));
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_210)));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
goto LA18_;
LA25_: ;
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_209)));
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
LA18_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 20) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 22):
{
{
tyObject_TType__facALICuu8zUj0hjvbTLFg* T31_;
T31_ = NIM_NIL;
T31_ = skipTypes__ast_3735((*n).typ, TM__BxLwT0mhrtgTPodf1v3xjg_211);
if (!((*T31_).kind == ((tyEnum_TTypeKind__9a3YiReNVD0IJHWFKgXRe9ag) 28))) goto LA32_;
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T38_;
if (!!((((*n)._kind_3.strVal ? (*n)._kind_3.strVal->Sup.len : 0) == ((NI) 0)))) goto LA36_;
useMagic__jsgen_779(p, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_212));
nimZeroMem((void*)T38_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T38_[0] = makeJSString__jsgen_378((*n)._kind_3.strVal, NIM_TRUE);
unsureAsgnRef((void**) (&(*r).res), percent___jsgen_6385(T38_, 1));
}
goto LA34_;
LA36_: ;
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_214)));
}
LA34_: ;
}
goto LA29_;
LA32_: ;
{
unsureAsgnRef((void**) (&(*r).res), makeJSString__jsgen_378((*n)._kind_3.strVal, NIM_FALSE));
}
LA29_: ;
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 16) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 18):
{
NF f;
tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA T42_;
f = (*n)._kind_2.floatVal;
T42_ = (tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA)0;
T42_ = classify__pureZmath_147(f);
switch (T42_) {
case ((tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA) 4):
{
{
NIM_BOOL T46_;
T46_ = (NIM_BOOL)0;
T46_ = signbit__astalgo_926(f);
if (!T46_) goto LA47_;
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_215)));
}
goto LA44_;
LA47_: ;
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_216)));
}
LA44_: ;
}
break;
case ((tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA) 3):
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_217)));
}
break;
case ((tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA) 2):
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_218)));
}
break;
case ((tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA) 5):
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_219)));
}
break;
case ((tyEnum_FloatClass__pPga1yW9b8J9cwNnm9b1aPRnA) 6):
{
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_220)));
}
break;
default:
{
NimStringDesc* T55_;
T55_ = NIM_NIL;
T55_ = toStrMaxPrecision__astalgo_920(f);
unsureAsgnRef((void**) (&(*r).res), rope__ropes_109(T55_));
}
break;
}
(*r).kind = ((tyEnum_TResKind__EoayJcDa8SxU1YPfjU8L9bg) 1);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 26) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 32):
{
{
NIM_BOOL T59_;
T59_ = (NIM_BOOL)0;
T59_ = isEmptyType__ast_4779((*n).typ);
if (!T59_) goto LA60_;
genLineDir__jsgen_1818(p, n);
}
LA60_: ;
{
NIM_BOOL T64_;
T64_ = (NIM_BOOL)0;
T64_ = ((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3));
if (!(T64_)) goto LA65_;
T64_ = !(((*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 0)));
LA65_: ;
if (!T64_) goto LA66_;
genMagic__jsgen_4598(p, n, r);
}
goto LA62_;
LA66_: ;
{
NIM_BOOL T69_;
NIM_BOOL T70_;
NI T73_;
T69_ = (NIM_BOOL)0;
T70_ = (NIM_BOOL)0;
T70_ = ((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 3));
if (!(T70_)) goto LA71_;
T70_ = (((*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 32))&63U)))!=0);
LA71_: ;
T69_ = T70_;
if (!(T69_)) goto LA72_;
T73_ = (NI)0;
T73_ = len__ast_3198(n);
T69_ = (((NI) 1) <= T73_);
LA72_: ;
if (!T69_) goto LA74_;
genInfixCall__jsgen_3688(p, n, r);
}
goto LA62_;
LA74_: ;
{
genCall__jsgen_3735(p, n, r);
}
LA62_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 155):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 39):
{
genSetConstr__jsgen_5219(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 41):
{
genArrayConstr__jsgen_5263(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 37):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 160):
{
genTupleConstr__jsgen_5289(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 38):
{
genObjConstr__jsgen_5328(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 58):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 59):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 60):
{
genConv__jsgen_5438(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 63):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 64):
{
genAddr__jsgen_2875(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 47):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 65):
{
genDeref__jsgen_3452(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 42):
{
genArrayAccess__jsgen_3014(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 45):
{
genFieldAccess__jsgen_2791(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 46):
{
genCheckedFieldOp__jsgen_2879(p, n, ((tyObject_TType__facALICuu8zUj0hjvbTLFg*) NIM_NIL), r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 66):
{
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 67):
{
upConv__jsgen_5730(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 61):
{
genCast__jsgen_6047(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 68):
{
genRangeChck__jsgen_5735(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_452));
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 69):
{
genRangeChck__jsgen_5735(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_453));
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 70):
{
genRangeChck__jsgen_5735(p, n, r, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_450));
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 71):
{
convStrToCStr__jsgen_5762(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 72):
{
convCStrToStr__jsgen_5783(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1):
{
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 51) ... ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 52):
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T98_;
s = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
T98_ = NIM_NIL;
T98_ = mangleName__jsgen_308((*p).module, s);
(void)(T98_);
unsureAsgnRef((void**) (&(*r).res), (*s).loc.r);
{
NIM_BOOL T101_;
T101_ = (NIM_BOOL)0;
T101_ = (((*s).loc.flags &((NU16)1<<((NU)(((tyEnum_TLocFlag__o2bqJgR4ceIupnUSpxiudA) 3))&15U)))!=0);
if (T101_) goto LA102_;
T101_ = !(((*s).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 0) || (*s).magic == ((tyEnum_TMagic__shZhZOdbVC5nnFvcXQAImg) 155)));
LA102_: ;
if (!T101_) goto LA103_;
}
goto LA99_;
LA103_: ;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym1175_;
NIM_BOOL T106_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T109_;
xX60gensym1175_ = s;
T106_ = (NIM_BOOL)0;
T106_ = containsOrIncl__astalgo_402((&(*(*p).g).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym1175_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym1175_).Sup.itemId.item))));
if (!!(T106_)) goto LA107_;
T109_ = NIM_NIL;
T109_ = genProc__jsgen_773(p, s);
add__ropes_159(&(*p).locals, T109_);
}
goto LA99_;
LA107_: ;
LA99_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 4):
{
unsureAsgnRef((void**) (&(*r).res), genTypeInfo__jsgen_385(p, (*n).typ));
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 115):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 126):
{
NIM_BOOL isExpr;
NIM_BOOL T112_;
T112_ = (NIM_BOOL)0;
T112_ = isEmptyType__ast_4779((*n).typ);
isExpr = !(T112_);
{
NI i;
NI colontmp_;
NI T114_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
T114_ = (NI)0;
T114_ = len__ast_3198(n);
colontmp_ = (NI)(T114_ - isExpr);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA116;
i = i_2;
genStmt__jsgen_770(p, (*n)._kind_6.sons->data[i]);
i_2 += ((NI) 1);
} LA116: ;
}
}
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T121_;
if (!isExpr) goto LA119_;
T121_ = NIM_NIL;
T121_ = lastSon__ast_4832(n);
gen__jsgen_766(p, T121_, r);
}
LA119_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 112):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 127):
{
genBlock__jsgen_2248(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 92):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 48):
{
genIf__jsgen_2358(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 93):
{
gen__jsgen_766(p, (*(*n)._kind_6.sons->data[((NI) 1)])._kind_6.sons->data[((NI) 0)], r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 96):
{
genWhileStmt__jsgen_1839(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 99):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 100):
{
genVarStmt__jsgen_4260(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 101):
{
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 94):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 95):
{
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_467), TM__BxLwT0mhrtgTPodf1v3xjg_468);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 97):
{
genCaseJS__jsgen_2140(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 109):
{
genReturnStmt__jsgen_5803(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 110):
{
genBreakStmt__jsgen_2292(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 73):
{
genAsgn__jsgen_2701(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 74):
{
genFastAsgn__jsgen_2706(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 114):
{
{
if (!!(((*(*n)._kind_6.sons->data[((NI) 0)]).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 1)))) goto LA137_;
genLineDir__jsgen_1818(p, n);
gen__jsgen_766(p, (*n)._kind_6.sons->data[((NI) 0)], r);
unsureAsgnRef((void**) (&(*r).res), amp___ropes_144(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_498), (*r).res));
}
LA137_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 89):
{
genAsmOrEmitStmt__jsgen_2330(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 106):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 154):
{
genTry__jsgen_1959(p, n, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 108):
{
genRaiseStmt__jsgen_2123(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 98):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 125):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 121):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 116):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 117):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 118):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 119):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 120):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 83):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 82):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 113):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 123):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 122):
{
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 84):
{
{
if (!((*(*(*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym).typ).callConv == ((tyEnum_TCallingConvention__yjAJ8w0h1PBaSwSGJ3P7IA) 9))) goto LA146_;
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_522), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 2), TM__BxLwT0mhrtgTPodf1v3xjg_523, NIM_FALSE);
}
LA146_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 90):
{
genPragma__jsgen_6039(p, n);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 79):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 159):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 80):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 81):
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s_2;
s_2 = (*(*n)._kind_6.sons->data[((NI) 0)])._kind_4.sym;
{
if (!((262272 & (*s_2).flags) == 128)) goto LA152_;
genSym__jsgen_3308(p, (*n)._kind_6.sons->data[((NI) 0)], r);
unsureAsgnRef((void**) (&(*r).res), ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL));
}
LA152_: ;
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 156):
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 157):
{
liMessage__msgs_1118((*(*p).module).config, (*n).info, ((tyEnum_TMsgKind__29cbg2fC1z5iM1PAI28kR5w) 14), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_524), ((tyEnum_TErrorHandling__q4fXoCN3Xdcm6SS9cUkWkWw) 2), TM__BxLwT0mhrtgTPodf1v3xjg_525, NIM_FALSE);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 91):
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* T156_;
T156_ = NIM_NIL;
T156_ = lastSon__ast_4832(n);
gen__jsgen_766(p, T156_, r);
}
break;
case ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 24):
{
}
break;
default:
{
NimStringDesc* T159_;
T159_ = NIM_NIL;
T159_ = rawNewString((reprEnum((NI)(*n).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)) ? reprEnum((NI)(*n).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_))->Sup.len : 0) + 24);
appendString(T159_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_526));
appendString(T159_, reprEnum((NI)(*n).kind, (&NTItnodekind__G4E4Gxe7oI2Cm03rkiOzQw_)));
internalErrorImpl__msgs_1431((*(*p).module).config, (*n).info, T159_, TM__BxLwT0mhrtgTPodf1v3xjg_527);
}
break;
}
}
N_LIB_PRIVATE N_NIMCALL(void, genStmt__jsgen_770)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w r;
nimZeroMem((void*)(&r), sizeof(tyObject_TCompRes__ZngkNoeBYb0CyBmkEOJi5w));
gen__jsgen_766(p, n, (&r));
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T5_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T6_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T7_;
if (!!((r.res == ((tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*) NIM_NIL)))) goto LA3_;
nimZeroMem((void*)T5_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T5_[0] = r.res;
T6_ = NIM_NIL;
T6_ = percent___cgen_13931(T5_, 1);
T7_ = NIM_NIL;
T7_ = indentLine__jsgen_97(p, T6_);
add__ropes_159(&(*p).body, T7_);
}
LA3_: ;
}
N_LIB_PRIVATE N_NIMCALL(void, addHcrInitGuards__jsgen_6528)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n, tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* moduleLoadedVar, NIM_BOOL* inInitGuard) {
{
if (!((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 115))) goto LA3_;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* child;
child = NIM_NIL;
{
NI i;
NI colontmp_;
NI i_2;
i = (NI)0;
colontmp_ = (NI)0;
colontmp_ = safeLen__ast_3191(n);
i_2 = ((NI) 0);
{
while (1) {
if (!(i_2 < colontmp_)) goto LA8;
i = i_2;
child = (*n)._kind_6.sons->data[i];
addHcrInitGuards__jsgen_6528(p, child, moduleLoadedVar, inInitGuard);
i_2 += ((NI) 1);
} LA8: ;
}
}
}
}
goto LA1_;
LA3_: ;
{
NIM_BOOL stmtShouldExecute;
NIM_BOOL T10_;
T10_ = (NIM_BOOL)0;
T10_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 79) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 159) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 80) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 81) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 99) || (*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 100));
if (T10_) goto LA11_;
T10_ = (((*n).flags &((NU32)1<<((NU)(((tyEnum_TNodeFlag__jyh9acXHkhZANSSvPIY7ZLg) 20))&31U)))!=0);
LA11_: ;
stmtShouldExecute = T10_;
{
if (!(*inInitGuard)) goto LA14_;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
if (!stmtShouldExecute) goto LA18_;
(*p).extraIndent -= ((NI) 1);
T20_ = NIM_NIL;
T20_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_25));
T21_ = NIM_NIL;
T21_ = indentLine__jsgen_97(p, T20_);
add__ropes_159(&(*p).body, T21_);
(*inInitGuard) = NIM_FALSE;
}
LA18_: ;
}
goto LA12_;
LA14_: ;
{
{
tyArray__JiWwrsTRC6xqNlGcBthSVA T27_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T28_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T29_;
if (!!(stmtShouldExecute)) goto LA25_;
nimZeroMem((void*)T27_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T27_[0] = moduleLoadedVar;
T28_ = NIM_NIL;
T28_ = percent___jsgen_6551(T27_, 1);
T29_ = NIM_NIL;
T29_ = indentLine__jsgen_97(p, T28_);
add__ropes_159(&(*p).body, T29_);
(*p).extraIndent += ((NI) 1);
(*inInitGuard) = NIM_TRUE;
}
LA25_: ;
}
LA12_: ;
genStmt__jsgen_770(p, n);
}
LA1_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, percent___jsgen_6587)(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA** args, NI argsLen_0) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
result = NIM_NIL;
result = runtimeFormat__ropes_271(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_528), args, argsLen_0);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, genModule__jsgen_6560)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* transformedN;
{
NimStringDesc* T5_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T6_;
NimStringDesc* T7_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T8_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T9_;
if (!(((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 17))&31U)))!=0)) goto LA3_;
T5_ = NIM_NIL;
T5_ = rawNewString(((*(*(*(*p).module).module).name).s ? (*(*(*(*p).module).module).name).s->Sup.len : 0) + 7);
appendString(T5_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_22));
appendString(T5_, (*(*(*(*p).module).module).name).s);
T6_ = NIM_NIL;
T6_ = makeJSString__jsgen_378(T5_, NIM_TRUE);
T7_ = NIM_NIL;
T7_ = toFilenameOption__msgs_590((*(*p).module).config, (*(*(*p).module).module).info.fileIndex, ((tyEnum_FilenameOption__eL86bAtPxXWHj24F5gOMFQ) 5));
T8_ = NIM_NIL;
T8_ = makeJSString__jsgen_378(T7_, NIM_TRUE);
T9_ = NIM_NIL;
T9_ = frameCreate__jsgen_5821(p, T6_, T8_);
add__ropes_159(&(*p).body, T9_);
}
LA3_: ;
transformedN = transformStmt__transf_1873((*(*p).module).graph, (*(*p).module).Sup.idgen, (*(*p).module).module, n);
{
if (!(((*(*(*p).module).module).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 42))&63U)))!=0)) goto LA12_;
transformedN = injectDestructorCalls__injectdestructors_10100((*(*p).module).graph, (*(*p).module).Sup.idgen, (*(*p).module).module, transformedN);
}
LA12_: ;
{
NIM_BOOL T16_;
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* moduleSym;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* moduleLoadedVar;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T20_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T21_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T22_;
tyArray__JiWwrsTRC6xqNlGcBthSVA T23_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T24_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T25_;
NIM_BOOL inGuardedBlock;
tyArray__JiWwrsTRC6xqNlGcBthSVA T32_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T33_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T34_;
T16_ = (NIM_BOOL)0;
T16_ = hcrOn__options_569((*(*p).module).config);
if (!(T16_)) goto LA17_;
T16_ = ((*n).kind == ((tyEnum_TNodeKind__G4E4Gxe7oI2Cm03rkiOzQw) 115));
LA17_: ;
if (!T16_) goto LA18_;
moduleSym = (*(*p).module).module;
T20_ = NIM_NIL;
T20_ = rope__ropes_109((*(*moduleSym).name).s);
T21_ = NIM_NIL;
T21_ = amp___ropes_140(T20_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_23));
T22_ = NIM_NIL;
T22_ = idOrSig__sighashes_2057(moduleSym, (*(*moduleSym).name).s, (&(*(*p).module).sigConflicts));
moduleLoadedVar = amp___ropes_128(T21_, T22_);
nimZeroMem((void*)T23_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T23_[0] = moduleLoadedVar;
T24_ = NIM_NIL;
T24_ = percent___jsgen_851(T23_, 1);
T25_ = NIM_NIL;
T25_ = indentLine__jsgen_97(p, T24_);
add__ropes_159(&(*p).body, T25_);
inGuardedBlock = NIM_FALSE;
addHcrInitGuards__jsgen_6528(p, transformedN, moduleLoadedVar, (&inGuardedBlock));
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T30_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T31_;
if (!inGuardedBlock) goto LA28_;
(*p).extraIndent -= ((NI) 1);
T30_ = NIM_NIL;
T30_ = rope__ropes_109(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_25));
T31_ = NIM_NIL;
T31_ = indentLine__jsgen_97(p, T30_);
add__ropes_159(&(*p).body, T31_);
}
LA28_: ;
nimZeroMem((void*)T32_, sizeof(tyArray__JiWwrsTRC6xqNlGcBthSVA));
T32_[0] = moduleLoadedVar;
T33_ = NIM_NIL;
T33_ = percent___jsgen_6587(T32_, 1);
T34_ = NIM_NIL;
T34_ = indentLine__jsgen_97(p, T33_);
add__ropes_159(&(*p).body, T34_);
}
goto LA14_;
LA18_: ;
{
genStmt__jsgen_770(p, transformedN);
}
LA14_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T40_;
if (!(((*p).options &((NU32)1<<((NU)(((tyEnum_TOption__WspMeQySXNP2XoTWR5MTgg) 17))&31U)))!=0)) goto LA38_;
T40_ = NIM_NIL;
T40_ = frameDestroy__jsgen_5837(p);
add__ropes_159(&(*p).body, T40_);
}
LA38_: ;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, myProcess__jsgen_6596)(tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* b, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* result;
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m;
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p;
{ result = NIM_NIL;
result = n;
m = ((tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*) (b));
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = skipCodegen__passes_49((*m).config, n);
if (!T3_) goto LA4_;
result = n;
goto BeforeRet_;
}
LA4_: ;
{
if (!((*m).module == ((tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ*) NIM_NIL))) goto LA8_;
internalErrorImpl__msgs_1431((*m).config, (*n).info, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_4), TM__BxLwT0mhrtgTPodf1v3xjg_5);
}
LA8_: ;
globals = (*((tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag**) (&((*(*m).graph).backend))));
p = newInitProc__jsgen_244(globals, m);
(*p).unique = (*globals).unique;
genModule__jsgen_6560(p, n);
add__ropes_159(&(*(*p).g).code, (*p).locals);
add__ropes_159(&(*(*p).g).code, (*p).body);
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, genHeader__jsgen_6526)(void) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
NimStringDesc* T1_;
NimStringDesc* T2_;
result = NIM_NIL;
T1_ = NIM_NIL;
T1_ = nsuUnindent(((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_529), ((NI) IL64(9223372036854775807)), ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_530));
T2_ = NIM_NIL;
T2_ = nsuFormatVarargs(T1_, TM__BxLwT0mhrtgTPodf1v3xjg_531, 1);
result = rope__ropes_109(T2_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, attachProc__jsgen_3218)(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p, tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* s) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* newp;
newp = genProc__jsgen_773(p, s);
attachProc__jsgen_3214(p, newp, s);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA*, wholeCode__jsgen_6607)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m) {
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* result;
tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag* globals;
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* disp;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T18_;
result = NIM_NIL;
globals = (*((tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag**) (&((*graph).backend))));
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ** prc;
NI i;
NI L;
NI T2_;
prc = (tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ**)0;
i = ((NI) 0);
T2_ = ((*globals).forwarded ? (*globals).forwarded->Sup.len : 0);
L = T2_;
{
while (1) {
if (!(i < L)) goto LA4;
prc = &(*globals).forwarded->data[i];
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym1212_;
NIM_BOOL T7_;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p;
xX60gensym1212_ = (*prc);
T7_ = (NIM_BOOL)0;
T7_ = containsOrIncl__astalgo_402((&(*globals).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym1212_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym1212_).Sup.itemId.item))));
if (!!(T7_)) goto LA8_;
p = newInitProc__jsgen_244(globals, m);
attachProc__jsgen_3218(p, (*prc));
}
LA8_: ;
i += ((NI) 1);
} LA4: ;
}
}
disp = generateMethodDispatchers__cgmeth_546(graph);
{
NI i_2;
NI colontmp_;
NI i_3;
i_2 = (NI)0;
colontmp_ = (NI)0;
colontmp_ = len__ast_3198(disp);
i_3 = ((NI) 0);
{
while (1) {
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* prc_2;
if (!(i_3 < colontmp_)) goto LA12;
i_2 = i_3;
prc_2 = (*(*disp)._kind_6.sons->data[i_2])._kind_4.sym;
{
tyObject_TSym__nnJKJFyjDGi5mnv8jwfTGQ* xX60gensym1214_;
NIM_BOOL T15_;
tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q* p_2;
xX60gensym1214_ = prc_2;
T15_ = (NIM_BOOL)0;
T15_ = containsOrIncl__astalgo_402((&(*globals).generatedSyms), (NI)((NI)((NU64)(((NI) ((*xX60gensym1214_).Sup.itemId.module))) << (NU64)(((NI) 24))) + ((NI) ((*xX60gensym1214_).Sup.itemId.item))));
if (!!(T15_)) goto LA16_;
p_2 = newInitProc__jsgen_244(globals, m);
attachProc__jsgen_3218(p_2, prc_2);
}
LA16_: ;
i_3 += ((NI) 1);
} LA12: ;
}
}
T18_ = NIM_NIL;
T18_ = amp___ropes_128((*globals).typeInfo, (*globals).constants);
result = amp___ropes_128(T18_, (*globals).code);
return result;
}
static N_INLINE(void, X5BX5Deq___pureZjson_1923)(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* obj, NimStringDesc* key, tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* val) {
X5BX5Deq___pureZjson_287((&(*obj)._kind_6.fields), key, val);
}
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6746)(NimStringDesc** elements, NI elementsLen_0) {
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* result;
result = NIM_NIL;
result = newJArray__pureZjson_123();
{
NimStringDesc** elem;
NI i;
elem = (NimStringDesc**)0;
i = ((NI) 0);
{
while (1) {
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T4_;
if (!(i < elementsLen_0)) goto LA3;
elem = (&elements[i]);
T4_ = NIM_NIL;
T4_ = percent___pureZjson_1790((*elem));
add__pureZjson_222(result, T4_);
i += ((NI) 1);
} LA3: ;
}
}
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6739)(tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* o) {
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* result;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T1_;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T2_;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T3_;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T4_;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T5_;
result = NIM_NIL;
result = newJObject__pureZjson_92();
T1_ = NIM_NIL;
T1_ = percent___pureZjson_1800((*o).version);
X5BX5Deq___pureZjson_1923(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_534), T1_);
T2_ = NIM_NIL;
T2_ = percent___jsgen_6746((*o).sources->data, ((*o).sources ? (*o).sources->Sup.len : 0));
X5BX5Deq___pureZjson_1923(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_535), T2_);
T3_ = NIM_NIL;
T3_ = percent___jsgen_6746((*o).names->data, ((*o).names ? (*o).names->Sup.len : 0));
X5BX5Deq___pureZjson_1923(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_536), T3_);
T4_ = NIM_NIL;
T4_ = percent___pureZjson_1790((*o).mappings);
X5BX5Deq___pureZjson_1923(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_537), T4_);
T5_ = NIM_NIL;
T5_ = percent___pureZjson_1790((*o).file);
X5BX5Deq___pureZjson_1923(result, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_538), T5_);
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q*, percent___jsgen_6732)(tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* o) {
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* result;
result = NIM_NIL;
{
if (!(o == 0)) goto LA3_;
result = newJNull__pureZjson_90();
}
goto LA1_;
LA3_: ;
{
result = percent___jsgen_6739((&(*o)));
}
LA1_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw*, myClose__jsgen_6698)(tyObject_ModuleGraphcolonObjectType___RZI3hCs0FTPYx8StfC81qQ* graph, tyObject_TPassContext__Hb6rFM0ecvtlLf2kv9aU75w* b, tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* n) {
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw* result;
tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw* m;
{ result = NIM_NIL;
result = myProcess__jsgen_6596(b, n);
m = ((tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*) (b));
{
if (!(((*(*m).module).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 14))&63U)))!=0)) goto LA3_;
{
tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw** destructorCall;
NI i;
NI L;
NI T6_;
destructorCall = (tyObject_TNode__bROa11lyF5vxEN9aYNbHmhw**)0;
i = ((NI) 0);
T6_ = ((*graph).globalDestructors ? (*graph).globalDestructors->Sup.len : 0);
L = T6_;
{
while (1) {
if (!(i < L)) goto LA8;
destructorCall = &(*graph).globalDestructors->data[i];
add__ast_4797(n, (*destructorCall));
i += ((NI) 1);
} LA8: ;
}
}
}
LA3_: ;
{
if (!(((*(*m).module).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 15))&63U)))!=0)) goto LA11_;
(*(*((tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag**) (&((*graph).backend))))).inSystem = NIM_FALSE;
}
LA11_: ;
{
NIM_BOOL T15_;
T15_ = (NIM_BOOL)0;
T15_ = skipCodegen__passes_49((*m).config, n);
if (!T15_) goto LA16_;
result = n;
goto BeforeRet_;
}
LA16_: ;
{
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* code;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T22_;
tyObject_RopeObj__OFzf0kSiPTcNreUIeJgWVA* T23_;
NimStringDesc* outFile;
NIM_BOOL T32_;
if (!(((*(*m).module).flags &((NU64)1<<((NU)(((tyEnum_TSymFlag__K9ay6LWMat9bUiT9bIbMxpDHw) 14))&63U)))!=0)) goto LA20_;
T22_ = NIM_NIL;
T22_ = genHeader__jsgen_6526();
T23_ = NIM_NIL;
T23_ = wholeCode__jsgen_6607(graph, m);
code = amp___ropes_128(T22_, T23_);
outFile = prepareToWriteOutput__options_4058((*m).config);
{
tyObject_SourceMapcolonObjectType___m1S8ZVbfoQLk0xvz8tc6ww* map;
tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg _;
NimStringDesc* T28_;
NimStringDesc* T29_;
tyObject_JsonNodeObj__df9bshXB7C9cTiWPIOtX3j1Q* T30_;
NimStringDesc* T31_;
if (!(((*(*m).config).globalOptions &((NU64)1<<((NU)(((tyEnum_TGlobalOption__RAfAEZqjnKMDumgyKKc1qw) 49))&63U)))!=0)) goto LA26_;
map = NIM_NIL;
nimZeroMem((void*)(&_), sizeof(tyTuple__wb7Ftwo1Ba9cOF5RERh5YIg));
T28_ = NIM_NIL;
T28_ = dollar___ropes_250(code);
genSourceMap__sourcemap_896(T28_, outFile, (&_));
code = _.Field0;
map = _.Field1;
T29_ = NIM_NIL;
T29_ = rawNewString((outFile ? outFile->Sup.len : 0) + 4);
appendString(T29_, outFile);
appendString(T29_, ((NimStringDesc*) &TM__BxLwT0mhrtgTPodf1v3xjg_533));
T30_ = NIM_NIL;
T30_ = percent___jsgen_6732(map);
T31_ = NIM_NIL;
T31_ = dollar___pureZjson_4465(T30_);
writeFile__systemZio_472(T29_, T31_);
}
LA26_: ;
T32_ = (NIM_BOOL)0;
T32_ = writeRopeIfNotEqual__ropes_458(code, outFile);
(void)(T32_);
}
LA20_: ;
}BeforeRet_: ;
return result;
}
N_LIB_PRIVATE N_NIMCALL(void, compiler_jsgenDatInit000)(void) {
static TNimNode* TM__BxLwT0mhrtgTPodf1v3xjg_2_4[4];
static TNimNode* TM__BxLwT0mhrtgTPodf1v3xjg_3_8[8];
static TNimNode* TM__BxLwT0mhrtgTPodf1v3xjg_7_15[15];
static TNimNode* TM__BxLwT0mhrtgTPodf1v3xjg_8_2[2];
static TNimNode* TM__BxLwT0mhrtgTPodf1v3xjg_492_10[10];
NI TM__BxLwT0mhrtgTPodf1v3xjg_494;
static char* NIM_CONST TM__BxLwT0mhrtgTPodf1v3xjg_493[10] = {
"etyNone",
"etyNull",
"etyProc",
"etyBool",
"etySeq",
"etyInt",
"etyFloat",
"etyString",
"etyObject",
"etyBaseIndex"};
static TNimNode TM__BxLwT0mhrtgTPodf1v3xjg_0[44];
NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_.size = sizeof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw);
NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_.align = NIM_ALIGNOF(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw);
NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_.kind = 17;
NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_.base = (&NTItpasscontext__Hb6rFM0ecvtlLf2kv9aU75w_);
TM__BxLwT0mhrtgTPodf1v3xjg_2_4[0] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[1];
TM__BxLwT0mhrtgTPodf1v3xjg_0[1].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[1].offset = offsetof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw, module);
TM__BxLwT0mhrtgTPodf1v3xjg_0[1].typ = (&NTIpsym__dG2QVH5Z69aMUY38zTqWxaA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[1].name = "module";
TM__BxLwT0mhrtgTPodf1v3xjg_2_4[1] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[2];
TM__BxLwT0mhrtgTPodf1v3xjg_0[2].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[2].offset = offsetof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw, graph);
TM__BxLwT0mhrtgTPodf1v3xjg_0[2].typ = (&NTImodulegraph__KfdHSsl8vyUCSI9b3inBcww_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[2].name = "graph";
TM__BxLwT0mhrtgTPodf1v3xjg_2_4[2] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[3];
TM__BxLwT0mhrtgTPodf1v3xjg_0[3].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[3].offset = offsetof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw, config);
TM__BxLwT0mhrtgTPodf1v3xjg_0[3].typ = (&NTIconfigref__a8lycfSA25OQltN3OMeBsA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[3].name = "config";
TM__BxLwT0mhrtgTPodf1v3xjg_2_4[3] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[4];
TM__BxLwT0mhrtgTPodf1v3xjg_0[4].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[4].offset = offsetof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw, sigConflicts);
TM__BxLwT0mhrtgTPodf1v3xjg_0[4].typ = (&NTIcounttable__tUMxxU9cRgLolsrW9b7IBGsQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[4].name = "sigConflicts";
TM__BxLwT0mhrtgTPodf1v3xjg_0[0].len = 4; TM__BxLwT0mhrtgTPodf1v3xjg_0[0].kind = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[0].sons = &TM__BxLwT0mhrtgTPodf1v3xjg_2_4[0];
NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_.node = &TM__BxLwT0mhrtgTPodf1v3xjg_0[0];
NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_.size = sizeof(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*);
NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_.align = NIM_ALIGNOF(tyObject_TJSGen__qij68Ti2EwJQHH6sSdkSdw*);
NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_.kind = 22;
NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_.base = (&NTItjsgen__qij68Ti2EwJQHH6sSdkSdw_);
NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_.marker = Marker_tyRef__O09bHTFgtn9cJLLJxiNhuKUA;
NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_.size = sizeof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag);
NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_.align = NIM_ALIGNOF(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag);
NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_.kind = 17;
NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_.base = (&NTIrootobj__ytyiCJqK439aF9cIibuRVpAg_);
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[0] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[6];
TM__BxLwT0mhrtgTPodf1v3xjg_0[6].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[6].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, typeInfo);
TM__BxLwT0mhrtgTPodf1v3xjg_0[6].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[6].name = "typeInfo";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[1] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[7];
TM__BxLwT0mhrtgTPodf1v3xjg_0[7].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[7].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, constants);
TM__BxLwT0mhrtgTPodf1v3xjg_0[7].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[7].name = "constants";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[2] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[8];
TM__BxLwT0mhrtgTPodf1v3xjg_0[8].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[8].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, code);
TM__BxLwT0mhrtgTPodf1v3xjg_0[8].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[8].name = "code";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[3] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[9];
TM__BxLwT0mhrtgTPodf1v3xjg_0[9].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[9].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, forwarded);
TM__BxLwT0mhrtgTPodf1v3xjg_0[9].typ = (&NTIseqLpsymT__eHqUwlHGGaPw0TDPDeL79cQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[9].name = "forwarded";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[4] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[10];
TM__BxLwT0mhrtgTPodf1v3xjg_0[10].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[10].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, generatedSyms);
TM__BxLwT0mhrtgTPodf1v3xjg_0[10].typ = (&NTIpackedset__IhxwDBRi51nGrosBGFKcsA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[10].name = "generatedSyms";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[5] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[11];
TM__BxLwT0mhrtgTPodf1v3xjg_0[11].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[11].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, typeInfoGenerated);
TM__BxLwT0mhrtgTPodf1v3xjg_0[11].typ = (&NTIpackedset__IhxwDBRi51nGrosBGFKcsA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[11].name = "typeInfoGenerated";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[6] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[12];
TM__BxLwT0mhrtgTPodf1v3xjg_0[12].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[12].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, unique);
TM__BxLwT0mhrtgTPodf1v3xjg_0[12].typ = (&NTIint__rR5Bzr1D5krxoo1NcNyeMA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[12].name = "unique";
TM__BxLwT0mhrtgTPodf1v3xjg_3_8[7] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[13];
TM__BxLwT0mhrtgTPodf1v3xjg_0[13].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[13].offset = offsetof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag, inSystem);
TM__BxLwT0mhrtgTPodf1v3xjg_0[13].typ = (&NTIbool__VaVACK0bpYmqIQ0mKcHfQQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[13].name = "inSystem";
TM__BxLwT0mhrtgTPodf1v3xjg_0[5].len = 8; TM__BxLwT0mhrtgTPodf1v3xjg_0[5].kind = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[5].sons = &TM__BxLwT0mhrtgTPodf1v3xjg_3_8[0];
NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_.node = &TM__BxLwT0mhrtgTPodf1v3xjg_0[5];
NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_.size = sizeof(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*);
NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_.align = NIM_ALIGNOF(tyObject_PGlobalscolonObjectType___nWsHZg3qCUsABoCNYLliag*);
NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_.kind = 22;
NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_.base = (&NTIpglobals58objecttype__nWsHZg3qCUsABoCNYLliag_);
NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_.marker = Marker_tyRef__Q8XTeJJ39cPFyNvJXj9bmcMQ;
NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_.size = sizeof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q);
NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_.align = NIM_ALIGNOF(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q);
NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_.kind = 18;
NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_.base = 0;
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[0] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[15];
TM__BxLwT0mhrtgTPodf1v3xjg_0[15].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[15].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, procDef);
TM__BxLwT0mhrtgTPodf1v3xjg_0[15].typ = (&NTIpnode__fKfcLzXYiz5jNu3NH3Tv8Q_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[15].name = "procDef";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[1] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[16];
TM__BxLwT0mhrtgTPodf1v3xjg_0[16].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[16].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, prc);
TM__BxLwT0mhrtgTPodf1v3xjg_0[16].typ = (&NTIpsym__dG2QVH5Z69aMUY38zTqWxaA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[16].name = "prc";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[2] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[17];
TM__BxLwT0mhrtgTPodf1v3xjg_0[17].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[17].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, globals);
TM__BxLwT0mhrtgTPodf1v3xjg_0[17].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[17].name = "globals";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[3] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[18];
TM__BxLwT0mhrtgTPodf1v3xjg_0[18].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[18].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, locals);
TM__BxLwT0mhrtgTPodf1v3xjg_0[18].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[18].name = "locals";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[4] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[19];
TM__BxLwT0mhrtgTPodf1v3xjg_0[19].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[19].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, body);
TM__BxLwT0mhrtgTPodf1v3xjg_0[19].typ = (&NTIrope__4hi0XQqK9aLiPuWT9acsXm9aQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[19].name = "body";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[5] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[20];
TM__BxLwT0mhrtgTPodf1v3xjg_0[20].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[20].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, options);
TM__BxLwT0mhrtgTPodf1v3xjg_0[20].typ = (&NTItoptions__7MnKRybmCNh5j9bDRLMkxLw_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[20].name = "options";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[6] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[21];
TM__BxLwT0mhrtgTPodf1v3xjg_0[21].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[21].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, module);
TM__BxLwT0mhrtgTPodf1v3xjg_0[21].typ = (&NTIbmodule__O09bHTFgtn9cJLLJxiNhuKUA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[21].name = "module";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[7] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[22];
TM__BxLwT0mhrtgTPodf1v3xjg_0[22].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[22].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, g);
TM__BxLwT0mhrtgTPodf1v3xjg_0[22].typ = (&NTIpglobals__Q8XTeJJ39cPFyNvJXj9bmcMQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[22].name = "g";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[8] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[23];
TM__BxLwT0mhrtgTPodf1v3xjg_0[23].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[23].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, generatedParamCopies);
TM__BxLwT0mhrtgTPodf1v3xjg_0[23].typ = (&NTIpackedset__IhxwDBRi51nGrosBGFKcsA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[23].name = "generatedParamCopies";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[9] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[24];
TM__BxLwT0mhrtgTPodf1v3xjg_0[24].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[24].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, beforeRetNeeded);
TM__BxLwT0mhrtgTPodf1v3xjg_0[24].typ = (&NTIbool__VaVACK0bpYmqIQ0mKcHfQQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[24].name = "beforeRetNeeded";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[10] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[25];
TM__BxLwT0mhrtgTPodf1v3xjg_0[25].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[25].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, unique);
TM__BxLwT0mhrtgTPodf1v3xjg_0[25].typ = (&NTIint__rR5Bzr1D5krxoo1NcNyeMA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[25].name = "unique";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[11] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[26];
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.size = sizeof(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg);
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.align = NIM_ALIGNOF(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg);
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.kind = 18;
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.base = 0;
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.flags = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_8_2[0] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[28];
TM__BxLwT0mhrtgTPodf1v3xjg_0[28].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[28].offset = offsetof(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg, id);
TM__BxLwT0mhrtgTPodf1v3xjg_0[28].typ = (&NTIint__rR5Bzr1D5krxoo1NcNyeMA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[28].name = "id";
TM__BxLwT0mhrtgTPodf1v3xjg_8_2[1] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[29];
TM__BxLwT0mhrtgTPodf1v3xjg_0[29].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[29].offset = offsetof(tyObject_TBlock__46cd0Xw9aDJ1QWTE8nV4mLg, isLoop);
TM__BxLwT0mhrtgTPodf1v3xjg_0[29].typ = (&NTIbool__VaVACK0bpYmqIQ0mKcHfQQ_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[29].name = "isLoop";
TM__BxLwT0mhrtgTPodf1v3xjg_0[27].len = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[27].kind = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[27].sons = &TM__BxLwT0mhrtgTPodf1v3xjg_8_2[0];
NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_.node = &TM__BxLwT0mhrtgTPodf1v3xjg_0[27];
NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_.size = sizeof(tySequence__8fytVdU59b5aj319cog2ztLw*);
NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_.align = NIM_ALIGNOF(tySequence__8fytVdU59b5aj319cog2ztLw*);
NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_.kind = 24;
NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_.base = (&NTItblock__46cd0Xw9aDJ1QWTE8nV4mLg_);
NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_.marker = Marker_tySequence__8fytVdU59b5aj319cog2ztLw;
TM__BxLwT0mhrtgTPodf1v3xjg_0[26].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[26].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, blocks);
TM__BxLwT0mhrtgTPodf1v3xjg_0[26].typ = (&NTIseqLtblockT__8fytVdU59b5aj319cog2ztLw_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[26].name = "blocks";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[12] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[30];
TM__BxLwT0mhrtgTPodf1v3xjg_0[30].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[30].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, extraIndent);
TM__BxLwT0mhrtgTPodf1v3xjg_0[30].typ = (&NTIint__rR5Bzr1D5krxoo1NcNyeMA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[30].name = "extraIndent";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[13] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[31];
TM__BxLwT0mhrtgTPodf1v3xjg_0[31].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[31].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, up);
TM__BxLwT0mhrtgTPodf1v3xjg_0[31].typ = (&NTIpproc__OFWibP8T8afo89apFNGZiwA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[31].name = "up";
TM__BxLwT0mhrtgTPodf1v3xjg_7_15[14] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[32];
TM__BxLwT0mhrtgTPodf1v3xjg_0[32].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[32].offset = offsetof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q, declaredGlobals);
TM__BxLwT0mhrtgTPodf1v3xjg_0[32].typ = (&NTIpackedset__IhxwDBRi51nGrosBGFKcsA_);
TM__BxLwT0mhrtgTPodf1v3xjg_0[32].name = "declaredGlobals";
TM__BxLwT0mhrtgTPodf1v3xjg_0[14].len = 15; TM__BxLwT0mhrtgTPodf1v3xjg_0[14].kind = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[14].sons = &TM__BxLwT0mhrtgTPodf1v3xjg_7_15[0];
NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_.node = &TM__BxLwT0mhrtgTPodf1v3xjg_0[14];
NTIpproc__OFWibP8T8afo89apFNGZiwA_.size = sizeof(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*);
NTIpproc__OFWibP8T8afo89apFNGZiwA_.align = NIM_ALIGNOF(tyObject_TProc__AFoo8FBR6Z1RtIhjuHkU2Q*);
NTIpproc__OFWibP8T8afo89apFNGZiwA_.kind = 22;
NTIpproc__OFWibP8T8afo89apFNGZiwA_.base = (&NTItproc__AFoo8FBR6Z1RtIhjuHkU2Q_);
NTIpproc__OFWibP8T8afo89apFNGZiwA_.marker = Marker_tyRef__OFWibP8T8afo89apFNGZiwA;
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.size = sizeof(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA);
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.align = NIM_ALIGNOF(tyEnum_TJSTypeKind__9aFSCXgaSEq2m81RJRMKDeA);
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.kind = 14;
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.base = 0;
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.flags = 3;
for (TM__BxLwT0mhrtgTPodf1v3xjg_494 = 0; TM__BxLwT0mhrtgTPodf1v3xjg_494 < 10; TM__BxLwT0mhrtgTPodf1v3xjg_494++) {
TM__BxLwT0mhrtgTPodf1v3xjg_0[TM__BxLwT0mhrtgTPodf1v3xjg_494+33].kind = 1;
TM__BxLwT0mhrtgTPodf1v3xjg_0[TM__BxLwT0mhrtgTPodf1v3xjg_494+33].offset = TM__BxLwT0mhrtgTPodf1v3xjg_494;
TM__BxLwT0mhrtgTPodf1v3xjg_0[TM__BxLwT0mhrtgTPodf1v3xjg_494+33].name = TM__BxLwT0mhrtgTPodf1v3xjg_493[TM__BxLwT0mhrtgTPodf1v3xjg_494];
TM__BxLwT0mhrtgTPodf1v3xjg_492_10[TM__BxLwT0mhrtgTPodf1v3xjg_494] = &TM__BxLwT0mhrtgTPodf1v3xjg_0[TM__BxLwT0mhrtgTPodf1v3xjg_494+33];
}
TM__BxLwT0mhrtgTPodf1v3xjg_0[43].len = 10; TM__BxLwT0mhrtgTPodf1v3xjg_0[43].kind = 2; TM__BxLwT0mhrtgTPodf1v3xjg_0[43].sons = &TM__BxLwT0mhrtgTPodf1v3xjg_492_10[0];
NTItjstypekind__9aFSCXgaSEq2m81RJRMKDeA_.node = &TM__BxLwT0mhrtgTPodf1v3xjg_0[43];
}
|
425182.c | /*
* Copyright (c) 2018 ISP RAS (http://www.ispras.ru)
* Ivannikov Institute for System Programming of the Russian Academy of Sciences
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <linux/module.h>
#include <ldv/common/test.h>
static int __init ldv_init(void)
{
int var1 = ldv_undef_int(), var2 = var1, var3 = ldv_undef_int();
var1 ^= var3;
if (var1 != (var2 ^ var3))
ldv_unexpected_error();
return 0;
}
module_init(ldv_init);
|
951334.c | #include <stdio.h>
int main(void)
{
int proverb_number;
printf("Enter proverb number: ");
scanf("%d", &proverb_number);
if (proverb_number == 1) printf("A bird in the hand...\n");
if (proverb_number == 2) printf("Arolling stone...\n");
if (proverb_number == 3) printf("Once buned, twice shy.\n");
if (proverb_number == 4) printf("Early to bed, early to rise...\n");
if (proverb_number == 5) printf("A penny saved in a penny earned.\n");
return 0;
} |
364805.c | #include <stdio.h>
int fib(int n)
{
if (n == 0 || n == 1)
{
return n;
}
return fib(n - 1) + fib(n - 2);
}
int main(void)
{
int a;
scanf("%d", &a);
int fib_number = fib(a);
for (a = 0; a < fib_number; a++){
printf("fib number is %d", fib_number);
}
return 0;
}
|
976472.c | /*
* Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
* From ASN.1 module "DSRC"
* found in "J2735_201603_ASN_CC.asn"
* `asn1c -gen-PER -fcompound-names -fincludes-quoted -fskeletons-copy`
*/
#include "SpeedLimit.h"
static asn_oer_constraints_t asn_OER_type_item_constr_3 CC_NOTUSED = {
{ 0, 0 },
-1};
static asn_per_constraints_t asn_PER_type_item_constr_3 CC_NOTUSED = {
{ APC_CONSTRAINED, 1, 1, 0, 1 } /* (0..1) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_oer_constraints_t asn_OER_type_SpeedLimit_constr_1 CC_NOTUSED = {
{ 0, 0 },
-1 /* (SIZE(1..16)) */};
asn_per_constraints_t asn_PER_type_SpeedLimit_constr_1 CC_NOTUSED = {
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
{ APC_CONSTRAINED, 4, 4, 1, 16 } /* (SIZE(1..16)) */,
0, 0 /* No PER value map */
};
static asn_TYPE_member_t asn_MBR_item_3[] = {
{ ATF_NOFLAGS, 0, offsetof(struct SpeedLimit__Member__item, choice.itis),
(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
-1, /* IMPLICIT tag at current level */
&asn_DEF_ITIScodes,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
"itis"
},
{ ATF_NOFLAGS, 0, offsetof(struct SpeedLimit__Member__item, choice.text),
(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
-1, /* IMPLICIT tag at current level */
&asn_DEF_ITIStextPhrase,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
"text"
},
};
static const asn_TYPE_tag2member_t asn_MAP_item_tag2el_3[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* itis */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* text */
};
static asn_CHOICE_specifics_t asn_SPC_item_specs_3 = {
sizeof(struct SpeedLimit__Member__item),
offsetof(struct SpeedLimit__Member__item, _asn_ctx),
offsetof(struct SpeedLimit__Member__item, present),
sizeof(((struct SpeedLimit__Member__item *)0)->present),
asn_MAP_item_tag2el_3,
2, /* Count of tags in the map */
0, 0,
-1 /* Extensions start */
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_item_3 = {
"item",
"item",
&asn_OP_CHOICE,
0, /* No effective tags (pointer) */
0, /* No effective tags (count) */
0, /* No tags (pointer) */
0, /* No tags (count) */
{ &asn_OER_type_item_constr_3, &asn_PER_type_item_constr_3, CHOICE_constraint },
asn_MBR_item_3,
2, /* Elements count */
&asn_SPC_item_specs_3 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Member_2[] = {
{ ATF_NOFLAGS, 0, offsetof(struct SpeedLimit__Member, item),
(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+1, /* EXPLICIT tag at current level */
&asn_DEF_item_3,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
"item"
},
};
static const ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static const asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* item */
};
static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
sizeof(struct SpeedLimit__Member),
offsetof(struct SpeedLimit__Member, _asn_ctx),
asn_MAP_Member_tag2el_2,
1, /* Count of tags in the map */
0, 0, 0, /* Optional elements (not needed) */
-1, /* First extension addition */
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_Member_2 = {
"SEQUENCE",
"SEQUENCE",
&asn_OP_SEQUENCE,
asn_DEF_Member_tags_2,
sizeof(asn_DEF_Member_tags_2)
/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
asn_DEF_Member_tags_2, /* Same as above */
sizeof(asn_DEF_Member_tags_2)
/sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
{ 0, 0, SEQUENCE_constraint },
asn_MBR_Member_2,
1, /* Elements count */
&asn_SPC_Member_specs_2 /* Additional specs */
};
asn_TYPE_member_t asn_MBR_SpeedLimit_1[] = {
{ ATF_POINTER, 0, 0,
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
0,
&asn_DEF_Member_2,
0,
{ 0, 0, 0 },
0, 0, /* No default value */
""
},
};
static const ber_tlv_tag_t asn_DEF_SpeedLimit_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
asn_SET_OF_specifics_t asn_SPC_SpeedLimit_specs_1 = {
sizeof(struct SpeedLimit),
offsetof(struct SpeedLimit, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
};
asn_TYPE_descriptor_t asn_DEF_SpeedLimit = {
"SpeedLimit",
"SpeedLimit",
&asn_OP_SEQUENCE_OF,
asn_DEF_SpeedLimit_tags_1,
sizeof(asn_DEF_SpeedLimit_tags_1)
/sizeof(asn_DEF_SpeedLimit_tags_1[0]), /* 1 */
asn_DEF_SpeedLimit_tags_1, /* Same as above */
sizeof(asn_DEF_SpeedLimit_tags_1)
/sizeof(asn_DEF_SpeedLimit_tags_1[0]), /* 1 */
{ &asn_OER_type_SpeedLimit_constr_1, &asn_PER_type_SpeedLimit_constr_1, SEQUENCE_OF_constraint },
asn_MBR_SpeedLimit_1,
1, /* Single element */
&asn_SPC_SpeedLimit_specs_1 /* Additional specs */
};
|
642496.c | /*
Simple DirectMedia Layer
Copyright (C) 1997-2019 Sam Lantinga <[email protected]>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"
#if SDL_VIDEO_DRIVER_KMSDRM
#include "SDL_kmsdrmvideo.h"
#include "SDL_kmsdrmevents.h"
#ifdef SDL_INPUT_LINUXEV
#include "../../core/linux/SDL_evdev.h"
#endif
void KMSDRM_PumpEvents(_THIS)
{
#ifdef SDL_INPUT_LINUXEV
SDL_EVDEV_Poll();
#endif
}
#endif /* SDL_VIDEO_DRIVER_KMSDRM */
|
222574.c | /*
* drivers/dma/fsl-edma.c
*
* Copyright 2013-2014 Freescale Semiconductor, Inc.
*
* Driver for the Freescale eDMA engine with flexible channel multiplexing
* capability for DMA request sources. The eDMA block can be found on some
* Vybrid and Layerscape SoCs.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_dma.h>
#include "virt-dma.h"
#define EDMA_CR 0x00
#define EDMA_ES 0x04
#define EDMA_ERQ 0x0C
#define EDMA_EEI 0x14
#define EDMA_SERQ 0x1B
#define EDMA_CERQ 0x1A
#define EDMA_SEEI 0x19
#define EDMA_CEEI 0x18
#define EDMA_CINT 0x1F
#define EDMA_CERR 0x1E
#define EDMA_SSRT 0x1D
#define EDMA_CDNE 0x1C
#define EDMA_INTR 0x24
#define EDMA_ERR 0x2C
#define EDMA_TCD_SADDR(x) (0x1000 + 32 * (x))
#define EDMA_TCD_SOFF(x) (0x1004 + 32 * (x))
#define EDMA_TCD_ATTR(x) (0x1006 + 32 * (x))
#define EDMA_TCD_NBYTES(x) (0x1008 + 32 * (x))
#define EDMA_TCD_SLAST(x) (0x100C + 32 * (x))
#define EDMA_TCD_DADDR(x) (0x1010 + 32 * (x))
#define EDMA_TCD_DOFF(x) (0x1014 + 32 * (x))
#define EDMA_TCD_CITER_ELINK(x) (0x1016 + 32 * (x))
#define EDMA_TCD_CITER(x) (0x1016 + 32 * (x))
#define EDMA_TCD_DLAST_SGA(x) (0x1018 + 32 * (x))
#define EDMA_TCD_CSR(x) (0x101C + 32 * (x))
#define EDMA_TCD_BITER_ELINK(x) (0x101E + 32 * (x))
#define EDMA_TCD_BITER(x) (0x101E + 32 * (x))
#define EDMA_CR_EDBG BIT(1)
#define EDMA_CR_ERCA BIT(2)
#define EDMA_CR_ERGA BIT(3)
#define EDMA_CR_HOE BIT(4)
#define EDMA_CR_HALT BIT(5)
#define EDMA_CR_CLM BIT(6)
#define EDMA_CR_EMLM BIT(7)
#define EDMA_CR_ECX BIT(16)
#define EDMA_CR_CX BIT(17)
#define EDMA_SEEI_SEEI(x) ((x) & 0x1F)
#define EDMA_CEEI_CEEI(x) ((x) & 0x1F)
#define EDMA_CINT_CINT(x) ((x) & 0x1F)
#define EDMA_CERR_CERR(x) ((x) & 0x1F)
#define EDMA_TCD_ATTR_DSIZE(x) (((x) & 0x0007))
#define EDMA_TCD_ATTR_DMOD(x) (((x) & 0x001F) << 3)
#define EDMA_TCD_ATTR_SSIZE(x) (((x) & 0x0007) << 8)
#define EDMA_TCD_ATTR_SMOD(x) (((x) & 0x001F) << 11)
#define EDMA_TCD_ATTR_SSIZE_8BIT (0x0000)
#define EDMA_TCD_ATTR_SSIZE_16BIT (0x0100)
#define EDMA_TCD_ATTR_SSIZE_32BIT (0x0200)
#define EDMA_TCD_ATTR_SSIZE_64BIT (0x0300)
#define EDMA_TCD_ATTR_SSIZE_32BYTE (0x0500)
#define EDMA_TCD_ATTR_DSIZE_8BIT (0x0000)
#define EDMA_TCD_ATTR_DSIZE_16BIT (0x0001)
#define EDMA_TCD_ATTR_DSIZE_32BIT (0x0002)
#define EDMA_TCD_ATTR_DSIZE_64BIT (0x0003)
#define EDMA_TCD_ATTR_DSIZE_32BYTE (0x0005)
#define EDMA_TCD_SOFF_SOFF(x) (x)
#define EDMA_TCD_NBYTES_NBYTES(x) (x)
#define EDMA_TCD_SLAST_SLAST(x) (x)
#define EDMA_TCD_DADDR_DADDR(x) (x)
#define EDMA_TCD_CITER_CITER(x) ((x) & 0x7FFF)
#define EDMA_TCD_DOFF_DOFF(x) (x)
#define EDMA_TCD_DLAST_SGA_DLAST_SGA(x) (x)
#define EDMA_TCD_BITER_BITER(x) ((x) & 0x7FFF)
#define EDMA_TCD_CSR_START BIT(0)
#define EDMA_TCD_CSR_INT_MAJOR BIT(1)
#define EDMA_TCD_CSR_INT_HALF BIT(2)
#define EDMA_TCD_CSR_D_REQ BIT(3)
#define EDMA_TCD_CSR_E_SG BIT(4)
#define EDMA_TCD_CSR_E_LINK BIT(5)
#define EDMA_TCD_CSR_ACTIVE BIT(6)
#define EDMA_TCD_CSR_DONE BIT(7)
#define EDMAMUX_CHCFG_DIS 0x0
#define EDMAMUX_CHCFG_ENBL 0x80
#define EDMAMUX_CHCFG_SOURCE(n) ((n) & 0x3F)
#define DMAMUX_NR 2
#define FSL_EDMA_BUSWIDTHS BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) | \
BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | \
BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
BIT(DMA_SLAVE_BUSWIDTH_8_BYTES)
struct fsl_edma_hw_tcd {
__le32 saddr;
__le16 soff;
__le16 attr;
__le32 nbytes;
__le32 slast;
__le32 daddr;
__le16 doff;
__le16 citer;
__le32 dlast_sga;
__le16 csr;
__le16 biter;
};
struct fsl_edma_sw_tcd {
dma_addr_t ptcd;
struct fsl_edma_hw_tcd *vtcd;
};
struct fsl_edma_slave_config {
enum dma_transfer_direction dir;
enum dma_slave_buswidth addr_width;
u32 dev_addr;
u32 burst;
u32 attr;
};
struct fsl_edma_chan {
struct virt_dma_chan vchan;
enum dma_status status;
struct fsl_edma_engine *edma;
struct fsl_edma_desc *edesc;
struct fsl_edma_slave_config fsc;
struct dma_pool *tcd_pool;
};
struct fsl_edma_desc {
struct virt_dma_desc vdesc;
struct fsl_edma_chan *echan;
bool iscyclic;
unsigned int n_tcds;
struct fsl_edma_sw_tcd tcd[];
};
struct fsl_edma_engine {
struct dma_device dma_dev;
void __iomem *membase;
void __iomem *muxbase[DMAMUX_NR];
struct clk *muxclk[DMAMUX_NR];
struct mutex fsl_edma_mutex;
u32 n_chans;
int txirq;
int errirq;
bool big_endian;
struct fsl_edma_chan chans[];
};
/*
* R/W functions for big- or little-endian registers:
* The eDMA controller's endian is independent of the CPU core's endian.
* For the big-endian IP module, the offset for 8-bit or 16-bit registers
* should also be swapped opposite to that in little-endian IP.
*/
static u32 edma_readl(struct fsl_edma_engine *edma, void __iomem *addr)
{
if (edma->big_endian)
return ioread32be(addr);
else
return ioread32(addr);
}
static void edma_writeb(struct fsl_edma_engine *edma, u8 val, void __iomem *addr)
{
/* swap the reg offset for these in big-endian mode */
if (edma->big_endian)
iowrite8(val, (void __iomem *)((unsigned long)addr ^ 0x3));
else
iowrite8(val, addr);
}
static void edma_writew(struct fsl_edma_engine *edma, u16 val, void __iomem *addr)
{
/* swap the reg offset for these in big-endian mode */
if (edma->big_endian)
iowrite16be(val, (void __iomem *)((unsigned long)addr ^ 0x2));
else
iowrite16(val, addr);
}
static void edma_writel(struct fsl_edma_engine *edma, u32 val, void __iomem *addr)
{
if (edma->big_endian)
iowrite32be(val, addr);
else
iowrite32(val, addr);
}
static struct fsl_edma_chan *to_fsl_edma_chan(struct dma_chan *chan)
{
return container_of(chan, struct fsl_edma_chan, vchan.chan);
}
static struct fsl_edma_desc *to_fsl_edma_desc(struct virt_dma_desc *vd)
{
return container_of(vd, struct fsl_edma_desc, vdesc);
}
static void fsl_edma_enable_request(struct fsl_edma_chan *fsl_chan)
{
void __iomem *addr = fsl_chan->edma->membase;
u32 ch = fsl_chan->vchan.chan.chan_id;
edma_writeb(fsl_chan->edma, EDMA_SEEI_SEEI(ch), addr + EDMA_SEEI);
edma_writeb(fsl_chan->edma, ch, addr + EDMA_SERQ);
}
static void fsl_edma_disable_request(struct fsl_edma_chan *fsl_chan)
{
void __iomem *addr = fsl_chan->edma->membase;
u32 ch = fsl_chan->vchan.chan.chan_id;
edma_writeb(fsl_chan->edma, ch, addr + EDMA_CERQ);
edma_writeb(fsl_chan->edma, EDMA_CEEI_CEEI(ch), addr + EDMA_CEEI);
}
static void fsl_edma_chan_mux(struct fsl_edma_chan *fsl_chan,
unsigned int slot, bool enable)
{
u32 ch = fsl_chan->vchan.chan.chan_id;
void __iomem *muxaddr;
unsigned chans_per_mux, ch_off;
chans_per_mux = fsl_chan->edma->n_chans / DMAMUX_NR;
ch_off = fsl_chan->vchan.chan.chan_id % chans_per_mux;
muxaddr = fsl_chan->edma->muxbase[ch / chans_per_mux];
slot = EDMAMUX_CHCFG_SOURCE(slot);
if (enable)
iowrite8(EDMAMUX_CHCFG_ENBL | slot, muxaddr + ch_off);
else
iowrite8(EDMAMUX_CHCFG_DIS, muxaddr + ch_off);
}
static unsigned int fsl_edma_get_tcd_attr(enum dma_slave_buswidth addr_width)
{
switch (addr_width) {
case 1:
return EDMA_TCD_ATTR_SSIZE_8BIT | EDMA_TCD_ATTR_DSIZE_8BIT;
case 2:
return EDMA_TCD_ATTR_SSIZE_16BIT | EDMA_TCD_ATTR_DSIZE_16BIT;
case 4:
return EDMA_TCD_ATTR_SSIZE_32BIT | EDMA_TCD_ATTR_DSIZE_32BIT;
case 8:
return EDMA_TCD_ATTR_SSIZE_64BIT | EDMA_TCD_ATTR_DSIZE_64BIT;
default:
return EDMA_TCD_ATTR_SSIZE_32BIT | EDMA_TCD_ATTR_DSIZE_32BIT;
}
}
static void fsl_edma_free_desc(struct virt_dma_desc *vdesc)
{
struct fsl_edma_desc *fsl_desc;
int i;
fsl_desc = to_fsl_edma_desc(vdesc);
for (i = 0; i < fsl_desc->n_tcds; i++)
dma_pool_free(fsl_desc->echan->tcd_pool, fsl_desc->tcd[i].vtcd,
fsl_desc->tcd[i].ptcd);
kfree(fsl_desc);
}
static int fsl_edma_terminate_all(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
unsigned long flags;
LIST_HEAD(head);
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
fsl_edma_disable_request(fsl_chan);
fsl_chan->edesc = NULL;
vchan_get_all_descriptors(&fsl_chan->vchan, &head);
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
vchan_dma_desc_free_list(&fsl_chan->vchan, &head);
return 0;
}
static int fsl_edma_pause(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
unsigned long flags;
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
if (fsl_chan->edesc) {
fsl_edma_disable_request(fsl_chan);
fsl_chan->status = DMA_PAUSED;
}
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
return 0;
}
static int fsl_edma_resume(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
unsigned long flags;
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
if (fsl_chan->edesc) {
fsl_edma_enable_request(fsl_chan);
fsl_chan->status = DMA_IN_PROGRESS;
}
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
return 0;
}
static int fsl_edma_slave_config(struct dma_chan *chan,
struct dma_slave_config *cfg)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
fsl_chan->fsc.dir = cfg->direction;
if (cfg->direction == DMA_DEV_TO_MEM) {
fsl_chan->fsc.dev_addr = cfg->src_addr;
fsl_chan->fsc.addr_width = cfg->src_addr_width;
fsl_chan->fsc.burst = cfg->src_maxburst;
fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->src_addr_width);
} else if (cfg->direction == DMA_MEM_TO_DEV) {
fsl_chan->fsc.dev_addr = cfg->dst_addr;
fsl_chan->fsc.addr_width = cfg->dst_addr_width;
fsl_chan->fsc.burst = cfg->dst_maxburst;
fsl_chan->fsc.attr = fsl_edma_get_tcd_attr(cfg->dst_addr_width);
} else {
return -EINVAL;
}
return 0;
}
static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan,
struct virt_dma_desc *vdesc, bool in_progress)
{
struct fsl_edma_desc *edesc = fsl_chan->edesc;
void __iomem *addr = fsl_chan->edma->membase;
u32 ch = fsl_chan->vchan.chan.chan_id;
enum dma_transfer_direction dir = fsl_chan->fsc.dir;
dma_addr_t cur_addr, dma_addr;
size_t len, size;
int i;
/* calculate the total size in this desc */
for (len = i = 0; i < fsl_chan->edesc->n_tcds; i++)
len += le32_to_cpu(edesc->tcd[i].vtcd->nbytes)
* le16_to_cpu(edesc->tcd[i].vtcd->biter);
if (!in_progress)
return len;
if (dir == DMA_MEM_TO_DEV)
cur_addr = edma_readl(fsl_chan->edma, addr + EDMA_TCD_SADDR(ch));
else
cur_addr = edma_readl(fsl_chan->edma, addr + EDMA_TCD_DADDR(ch));
/* figure out the finished and calculate the residue */
for (i = 0; i < fsl_chan->edesc->n_tcds; i++) {
size = le32_to_cpu(edesc->tcd[i].vtcd->nbytes)
* le16_to_cpu(edesc->tcd[i].vtcd->biter);
if (dir == DMA_MEM_TO_DEV)
dma_addr = le32_to_cpu(edesc->tcd[i].vtcd->saddr);
else
dma_addr = le32_to_cpu(edesc->tcd[i].vtcd->daddr);
len -= size;
if (cur_addr >= dma_addr && cur_addr < dma_addr + size) {
len += dma_addr + size - cur_addr;
break;
}
}
return len;
}
static enum dma_status fsl_edma_tx_status(struct dma_chan *chan,
dma_cookie_t cookie, struct dma_tx_state *txstate)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
struct virt_dma_desc *vdesc;
enum dma_status status;
unsigned long flags;
status = dma_cookie_status(chan, cookie, txstate);
if (status == DMA_COMPLETE)
return status;
if (!txstate)
return fsl_chan->status;
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
vdesc = vchan_find_desc(&fsl_chan->vchan, cookie);
if (fsl_chan->edesc && cookie == fsl_chan->edesc->vdesc.tx.cookie)
txstate->residue = fsl_edma_desc_residue(fsl_chan, vdesc, true);
else if (vdesc)
txstate->residue = fsl_edma_desc_residue(fsl_chan, vdesc, false);
else
txstate->residue = 0;
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
return fsl_chan->status;
}
static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan,
struct fsl_edma_hw_tcd *tcd)
{
struct fsl_edma_engine *edma = fsl_chan->edma;
void __iomem *addr = fsl_chan->edma->membase;
u32 ch = fsl_chan->vchan.chan.chan_id;
/*
* TCD parameters are stored in struct fsl_edma_hw_tcd in little
* endian format. However, we need to load the TCD registers in
* big- or little-endian obeying the eDMA engine model endian.
*/
edma_writew(edma, 0, addr + EDMA_TCD_CSR(ch));
edma_writel(edma, le32_to_cpu(tcd->saddr), addr + EDMA_TCD_SADDR(ch));
edma_writel(edma, le32_to_cpu(tcd->daddr), addr + EDMA_TCD_DADDR(ch));
edma_writew(edma, le16_to_cpu(tcd->attr), addr + EDMA_TCD_ATTR(ch));
edma_writew(edma, le16_to_cpu(tcd->soff), addr + EDMA_TCD_SOFF(ch));
edma_writel(edma, le32_to_cpu(tcd->nbytes), addr + EDMA_TCD_NBYTES(ch));
edma_writel(edma, le32_to_cpu(tcd->slast), addr + EDMA_TCD_SLAST(ch));
edma_writew(edma, le16_to_cpu(tcd->citer), addr + EDMA_TCD_CITER(ch));
edma_writew(edma, le16_to_cpu(tcd->biter), addr + EDMA_TCD_BITER(ch));
edma_writew(edma, le16_to_cpu(tcd->doff), addr + EDMA_TCD_DOFF(ch));
edma_writel(edma, le32_to_cpu(tcd->dlast_sga), addr + EDMA_TCD_DLAST_SGA(ch));
edma_writew(edma, le16_to_cpu(tcd->csr), addr + EDMA_TCD_CSR(ch));
}
static inline
void fsl_edma_fill_tcd(struct fsl_edma_hw_tcd *tcd, u32 src, u32 dst,
u16 attr, u16 soff, u32 nbytes, u32 slast, u16 citer,
u16 biter, u16 doff, u32 dlast_sga, bool major_int,
bool disable_req, bool enable_sg)
{
u16 csr = 0;
/*
* eDMA hardware SGs require the TCDs to be stored in little
* endian format irrespective of the register endian model.
* So we put the value in little endian in memory, waiting
* for fsl_edma_set_tcd_regs doing the swap.
*/
tcd->saddr = cpu_to_le32(src);
tcd->daddr = cpu_to_le32(dst);
tcd->attr = cpu_to_le16(attr);
tcd->soff = cpu_to_le16(EDMA_TCD_SOFF_SOFF(soff));
tcd->nbytes = cpu_to_le32(EDMA_TCD_NBYTES_NBYTES(nbytes));
tcd->slast = cpu_to_le32(EDMA_TCD_SLAST_SLAST(slast));
tcd->citer = cpu_to_le16(EDMA_TCD_CITER_CITER(citer));
tcd->doff = cpu_to_le16(EDMA_TCD_DOFF_DOFF(doff));
tcd->dlast_sga = cpu_to_le32(EDMA_TCD_DLAST_SGA_DLAST_SGA(dlast_sga));
tcd->biter = cpu_to_le16(EDMA_TCD_BITER_BITER(biter));
if (major_int)
csr |= EDMA_TCD_CSR_INT_MAJOR;
if (disable_req)
csr |= EDMA_TCD_CSR_D_REQ;
if (enable_sg)
csr |= EDMA_TCD_CSR_E_SG;
tcd->csr = cpu_to_le16(csr);
}
static struct fsl_edma_desc *fsl_edma_alloc_desc(struct fsl_edma_chan *fsl_chan,
int sg_len)
{
struct fsl_edma_desc *fsl_desc;
int i;
fsl_desc = kzalloc(sizeof(*fsl_desc) + sizeof(struct fsl_edma_sw_tcd) * sg_len,
GFP_NOWAIT);
if (!fsl_desc)
return NULL;
fsl_desc->echan = fsl_chan;
fsl_desc->n_tcds = sg_len;
for (i = 0; i < sg_len; i++) {
fsl_desc->tcd[i].vtcd = dma_pool_alloc(fsl_chan->tcd_pool,
GFP_NOWAIT, &fsl_desc->tcd[i].ptcd);
if (!fsl_desc->tcd[i].vtcd)
goto err;
}
return fsl_desc;
err:
while (--i >= 0)
dma_pool_free(fsl_chan->tcd_pool, fsl_desc->tcd[i].vtcd,
fsl_desc->tcd[i].ptcd);
kfree(fsl_desc);
return NULL;
}
static struct dma_async_tx_descriptor *fsl_edma_prep_dma_cyclic(
struct dma_chan *chan, dma_addr_t dma_addr, size_t buf_len,
size_t period_len, enum dma_transfer_direction direction,
unsigned long flags)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
struct fsl_edma_desc *fsl_desc;
dma_addr_t dma_buf_next;
int sg_len, i;
u32 src_addr, dst_addr, last_sg, nbytes;
u16 soff, doff, iter;
if (!is_slave_direction(fsl_chan->fsc.dir))
return NULL;
sg_len = buf_len / period_len;
fsl_desc = fsl_edma_alloc_desc(fsl_chan, sg_len);
if (!fsl_desc)
return NULL;
fsl_desc->iscyclic = true;
dma_buf_next = dma_addr;
nbytes = fsl_chan->fsc.addr_width * fsl_chan->fsc.burst;
iter = period_len / nbytes;
for (i = 0; i < sg_len; i++) {
if (dma_buf_next >= dma_addr + buf_len)
dma_buf_next = dma_addr;
/* get next sg's physical address */
last_sg = fsl_desc->tcd[(i + 1) % sg_len].ptcd;
if (fsl_chan->fsc.dir == DMA_MEM_TO_DEV) {
src_addr = dma_buf_next;
dst_addr = fsl_chan->fsc.dev_addr;
soff = fsl_chan->fsc.addr_width;
doff = 0;
} else {
src_addr = fsl_chan->fsc.dev_addr;
dst_addr = dma_buf_next;
soff = 0;
doff = fsl_chan->fsc.addr_width;
}
fsl_edma_fill_tcd(fsl_desc->tcd[i].vtcd, src_addr, dst_addr,
fsl_chan->fsc.attr, soff, nbytes, 0, iter,
iter, doff, last_sg, true, false, true);
dma_buf_next += period_len;
}
return vchan_tx_prep(&fsl_chan->vchan, &fsl_desc->vdesc, flags);
}
static struct dma_async_tx_descriptor *fsl_edma_prep_slave_sg(
struct dma_chan *chan, struct scatterlist *sgl,
unsigned int sg_len, enum dma_transfer_direction direction,
unsigned long flags, void *context)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
struct fsl_edma_desc *fsl_desc;
struct scatterlist *sg;
u32 src_addr, dst_addr, last_sg, nbytes;
u16 soff, doff, iter;
int i;
if (!is_slave_direction(fsl_chan->fsc.dir))
return NULL;
fsl_desc = fsl_edma_alloc_desc(fsl_chan, sg_len);
if (!fsl_desc)
return NULL;
fsl_desc->iscyclic = false;
nbytes = fsl_chan->fsc.addr_width * fsl_chan->fsc.burst;
for_each_sg(sgl, sg, sg_len, i) {
/* get next sg's physical address */
last_sg = fsl_desc->tcd[(i + 1) % sg_len].ptcd;
if (fsl_chan->fsc.dir == DMA_MEM_TO_DEV) {
src_addr = sg_dma_address(sg);
dst_addr = fsl_chan->fsc.dev_addr;
soff = fsl_chan->fsc.addr_width;
doff = 0;
} else {
src_addr = fsl_chan->fsc.dev_addr;
dst_addr = sg_dma_address(sg);
soff = 0;
doff = fsl_chan->fsc.addr_width;
}
iter = sg_dma_len(sg) / nbytes;
if (i < sg_len - 1) {
last_sg = fsl_desc->tcd[(i + 1)].ptcd;
fsl_edma_fill_tcd(fsl_desc->tcd[i].vtcd, src_addr,
dst_addr, fsl_chan->fsc.attr, soff,
nbytes, 0, iter, iter, doff, last_sg,
false, false, true);
} else {
last_sg = 0;
fsl_edma_fill_tcd(fsl_desc->tcd[i].vtcd, src_addr,
dst_addr, fsl_chan->fsc.attr, soff,
nbytes, 0, iter, iter, doff, last_sg,
true, true, false);
}
}
return vchan_tx_prep(&fsl_chan->vchan, &fsl_desc->vdesc, flags);
}
static void fsl_edma_xfer_desc(struct fsl_edma_chan *fsl_chan)
{
struct virt_dma_desc *vdesc;
vdesc = vchan_next_desc(&fsl_chan->vchan);
if (!vdesc)
return;
fsl_chan->edesc = to_fsl_edma_desc(vdesc);
fsl_edma_set_tcd_regs(fsl_chan, fsl_chan->edesc->tcd[0].vtcd);
fsl_edma_enable_request(fsl_chan);
fsl_chan->status = DMA_IN_PROGRESS;
}
static irqreturn_t fsl_edma_tx_handler(int irq, void *dev_id)
{
struct fsl_edma_engine *fsl_edma = dev_id;
unsigned int intr, ch;
void __iomem *base_addr;
struct fsl_edma_chan *fsl_chan;
base_addr = fsl_edma->membase;
intr = edma_readl(fsl_edma, base_addr + EDMA_INTR);
if (!intr)
return IRQ_NONE;
for (ch = 0; ch < fsl_edma->n_chans; ch++) {
if (intr & (0x1 << ch)) {
edma_writeb(fsl_edma, EDMA_CINT_CINT(ch),
base_addr + EDMA_CINT);
fsl_chan = &fsl_edma->chans[ch];
spin_lock(&fsl_chan->vchan.lock);
if (!fsl_chan->edesc->iscyclic) {
list_del(&fsl_chan->edesc->vdesc.node);
vchan_cookie_complete(&fsl_chan->edesc->vdesc);
fsl_chan->edesc = NULL;
fsl_chan->status = DMA_COMPLETE;
} else {
vchan_cyclic_callback(&fsl_chan->edesc->vdesc);
}
if (!fsl_chan->edesc)
fsl_edma_xfer_desc(fsl_chan);
spin_unlock(&fsl_chan->vchan.lock);
}
}
return IRQ_HANDLED;
}
static irqreturn_t fsl_edma_err_handler(int irq, void *dev_id)
{
struct fsl_edma_engine *fsl_edma = dev_id;
unsigned int err, ch;
err = edma_readl(fsl_edma, fsl_edma->membase + EDMA_ERR);
if (!err)
return IRQ_NONE;
for (ch = 0; ch < fsl_edma->n_chans; ch++) {
if (err & (0x1 << ch)) {
fsl_edma_disable_request(&fsl_edma->chans[ch]);
edma_writeb(fsl_edma, EDMA_CERR_CERR(ch),
fsl_edma->membase + EDMA_CERR);
fsl_edma->chans[ch].status = DMA_ERROR;
}
}
return IRQ_HANDLED;
}
static irqreturn_t fsl_edma_irq_handler(int irq, void *dev_id)
{
if (fsl_edma_tx_handler(irq, dev_id) == IRQ_HANDLED)
return IRQ_HANDLED;
return fsl_edma_err_handler(irq, dev_id);
}
static void fsl_edma_issue_pending(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
unsigned long flags;
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
if (vchan_issue_pending(&fsl_chan->vchan) && !fsl_chan->edesc)
fsl_edma_xfer_desc(fsl_chan);
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
}
static struct dma_chan *fsl_edma_xlate(struct of_phandle_args *dma_spec,
struct of_dma *ofdma)
{
struct fsl_edma_engine *fsl_edma = ofdma->of_dma_data;
struct dma_chan *chan, *_chan;
unsigned long chans_per_mux = fsl_edma->n_chans / DMAMUX_NR;
if (dma_spec->args_count != 2)
return NULL;
mutex_lock(&fsl_edma->fsl_edma_mutex);
list_for_each_entry_safe(chan, _chan, &fsl_edma->dma_dev.channels, device_node) {
if (chan->client_count)
continue;
if ((chan->chan_id / chans_per_mux) == dma_spec->args[0]) {
chan = dma_get_slave_channel(chan);
if (chan) {
chan->device->privatecnt++;
fsl_edma_chan_mux(to_fsl_edma_chan(chan),
dma_spec->args[1], true);
mutex_unlock(&fsl_edma->fsl_edma_mutex);
return chan;
}
}
}
mutex_unlock(&fsl_edma->fsl_edma_mutex);
return NULL;
}
static int fsl_edma_alloc_chan_resources(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
fsl_chan->tcd_pool = dma_pool_create("tcd_pool", chan->device->dev,
sizeof(struct fsl_edma_hw_tcd),
32, 0);
return 0;
}
static void fsl_edma_free_chan_resources(struct dma_chan *chan)
{
struct fsl_edma_chan *fsl_chan = to_fsl_edma_chan(chan);
unsigned long flags;
LIST_HEAD(head);
spin_lock_irqsave(&fsl_chan->vchan.lock, flags);
fsl_edma_disable_request(fsl_chan);
fsl_edma_chan_mux(fsl_chan, 0, false);
fsl_chan->edesc = NULL;
vchan_get_all_descriptors(&fsl_chan->vchan, &head);
spin_unlock_irqrestore(&fsl_chan->vchan.lock, flags);
vchan_dma_desc_free_list(&fsl_chan->vchan, &head);
dma_pool_destroy(fsl_chan->tcd_pool);
fsl_chan->tcd_pool = NULL;
}
static int
fsl_edma_irq_init(struct platform_device *pdev, struct fsl_edma_engine *fsl_edma)
{
int ret;
fsl_edma->txirq = platform_get_irq_byname(pdev, "edma-tx");
if (fsl_edma->txirq < 0) {
dev_err(&pdev->dev, "Can't get edma-tx irq.\n");
return fsl_edma->txirq;
}
fsl_edma->errirq = platform_get_irq_byname(pdev, "edma-err");
if (fsl_edma->errirq < 0) {
dev_err(&pdev->dev, "Can't get edma-err irq.\n");
return fsl_edma->errirq;
}
if (fsl_edma->txirq == fsl_edma->errirq) {
ret = devm_request_irq(&pdev->dev, fsl_edma->txirq,
fsl_edma_irq_handler, 0, "eDMA", fsl_edma);
if (ret) {
dev_err(&pdev->dev, "Can't register eDMA IRQ.\n");
return ret;
}
} else {
ret = devm_request_irq(&pdev->dev, fsl_edma->txirq,
fsl_edma_tx_handler, 0, "eDMA tx", fsl_edma);
if (ret) {
dev_err(&pdev->dev, "Can't register eDMA tx IRQ.\n");
return ret;
}
ret = devm_request_irq(&pdev->dev, fsl_edma->errirq,
fsl_edma_err_handler, 0, "eDMA err", fsl_edma);
if (ret) {
dev_err(&pdev->dev, "Can't register eDMA err IRQ.\n");
return ret;
}
}
return 0;
}
static int fsl_edma_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct fsl_edma_engine *fsl_edma;
struct fsl_edma_chan *fsl_chan;
struct resource *res;
int len, chans;
int ret, i;
ret = of_property_read_u32(np, "dma-channels", &chans);
if (ret) {
dev_err(&pdev->dev, "Can't get dma-channels.\n");
return ret;
}
len = sizeof(*fsl_edma) + sizeof(*fsl_chan) * chans;
fsl_edma = devm_kzalloc(&pdev->dev, len, GFP_KERNEL);
if (!fsl_edma)
return -ENOMEM;
fsl_edma->n_chans = chans;
mutex_init(&fsl_edma->fsl_edma_mutex);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
fsl_edma->membase = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(fsl_edma->membase))
return PTR_ERR(fsl_edma->membase);
for (i = 0; i < DMAMUX_NR; i++) {
char clkname[32];
res = platform_get_resource(pdev, IORESOURCE_MEM, 1 + i);
fsl_edma->muxbase[i] = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(fsl_edma->muxbase[i]))
return PTR_ERR(fsl_edma->muxbase[i]);
sprintf(clkname, "dmamux%d", i);
fsl_edma->muxclk[i] = devm_clk_get(&pdev->dev, clkname);
if (IS_ERR(fsl_edma->muxclk[i])) {
dev_err(&pdev->dev, "Missing DMAMUX block clock.\n");
return PTR_ERR(fsl_edma->muxclk[i]);
}
ret = clk_prepare_enable(fsl_edma->muxclk[i]);
if (ret) {
dev_err(&pdev->dev, "DMAMUX clk block failed.\n");
return ret;
}
}
fsl_edma->big_endian = of_property_read_bool(np, "big-endian");
INIT_LIST_HEAD(&fsl_edma->dma_dev.channels);
for (i = 0; i < fsl_edma->n_chans; i++) {
struct fsl_edma_chan *fsl_chan = &fsl_edma->chans[i];
fsl_chan->edma = fsl_edma;
fsl_chan->vchan.desc_free = fsl_edma_free_desc;
vchan_init(&fsl_chan->vchan, &fsl_edma->dma_dev);
edma_writew(fsl_edma, 0x0, fsl_edma->membase + EDMA_TCD_CSR(i));
fsl_edma_chan_mux(fsl_chan, 0, false);
}
edma_writel(fsl_edma, ~0, fsl_edma->membase + EDMA_INTR);
ret = fsl_edma_irq_init(pdev, fsl_edma);
if (ret)
return ret;
dma_cap_set(DMA_PRIVATE, fsl_edma->dma_dev.cap_mask);
dma_cap_set(DMA_SLAVE, fsl_edma->dma_dev.cap_mask);
dma_cap_set(DMA_CYCLIC, fsl_edma->dma_dev.cap_mask);
fsl_edma->dma_dev.dev = &pdev->dev;
fsl_edma->dma_dev.device_alloc_chan_resources
= fsl_edma_alloc_chan_resources;
fsl_edma->dma_dev.device_free_chan_resources
= fsl_edma_free_chan_resources;
fsl_edma->dma_dev.device_tx_status = fsl_edma_tx_status;
fsl_edma->dma_dev.device_prep_slave_sg = fsl_edma_prep_slave_sg;
fsl_edma->dma_dev.device_prep_dma_cyclic = fsl_edma_prep_dma_cyclic;
fsl_edma->dma_dev.device_config = fsl_edma_slave_config;
fsl_edma->dma_dev.device_pause = fsl_edma_pause;
fsl_edma->dma_dev.device_resume = fsl_edma_resume;
fsl_edma->dma_dev.device_terminate_all = fsl_edma_terminate_all;
fsl_edma->dma_dev.device_issue_pending = fsl_edma_issue_pending;
fsl_edma->dma_dev.src_addr_widths = FSL_EDMA_BUSWIDTHS;
fsl_edma->dma_dev.dst_addr_widths = FSL_EDMA_BUSWIDTHS;
fsl_edma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
platform_set_drvdata(pdev, fsl_edma);
ret = dma_async_device_register(&fsl_edma->dma_dev);
if (ret) {
dev_err(&pdev->dev, "Can't register Freescale eDMA engine.\n");
return ret;
}
ret = of_dma_controller_register(np, fsl_edma_xlate, fsl_edma);
if (ret) {
dev_err(&pdev->dev, "Can't register Freescale eDMA of_dma.\n");
dma_async_device_unregister(&fsl_edma->dma_dev);
return ret;
}
/* enable round robin arbitration */
edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, fsl_edma->membase + EDMA_CR);
return 0;
}
static int fsl_edma_remove(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct fsl_edma_engine *fsl_edma = platform_get_drvdata(pdev);
int i;
of_dma_controller_free(np);
dma_async_device_unregister(&fsl_edma->dma_dev);
for (i = 0; i < DMAMUX_NR; i++)
clk_disable_unprepare(fsl_edma->muxclk[i]);
return 0;
}
static const struct of_device_id fsl_edma_dt_ids[] = {
{ .compatible = "fsl,vf610-edma", },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, fsl_edma_dt_ids);
static struct platform_driver fsl_edma_driver = {
.driver = {
.name = "fsl-edma",
.of_match_table = fsl_edma_dt_ids,
},
.probe = fsl_edma_probe,
.remove = fsl_edma_remove,
};
static int __init fsl_edma_init(void)
{
return platform_driver_register(&fsl_edma_driver);
}
subsys_initcall(fsl_edma_init);
static void __exit fsl_edma_exit(void)
{
platform_driver_unregister(&fsl_edma_driver);
}
module_exit(fsl_edma_exit);
MODULE_ALIAS("platform:fsl-edma");
MODULE_DESCRIPTION("Freescale eDMA engine driver");
MODULE_LICENSE("GPL v2");
|
205232.c | /* Copyright (c) Hisilicon Technologies Co., Ltd. 2013-2019. All rights reserved.
* FileName: ion_tee_op.c
* Description: This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation;
* either version 2 of the License,
* or (at your option) any later version.
*/
#define pr_fmt(fmt) "secsg: " fmt
#include <linux/err.h>
#include <linux/sizes.h>
#include <linux/hisi/hisi_ion.h>
#include <teek_client_api.h>
#include <teek_client_id.h>
#include <teek_client_constants.h>
#include "ion.h"
#include "hisi_ion_priv.h"
#include "ion_tee_op.h"
#define ROOTID 2000
/* uuid to TA: f8028dca-aba0-11e6-80f5-76304dec7eb7 */
#define UUID_TEEOS_TZMP2_IonMemoryManagement \
{ \
0xf8028dca,\
0xaba0,\
0x11e6,\
{ \
0x80, 0xf5, 0x76, 0x30, 0x4d, 0xec, 0x7e, 0xb7 \
} \
}
int secmem_tee_init(TEEC_Context *context, TEEC_Session *session)
{
u32 root_id = ROOTID;
const char *package_name = "sec_mem";
TEEC_UUID svc_id = UUID_TEEOS_TZMP2_IonMemoryManagement;
TEEC_Operation op = {0};
TEEC_Result result;
u32 origin = 0;
if (!context || !session) {
pr_err("Invalid context or session\n");
goto cleanup_1;
}
/* initialize TEE environment */
result = TEEK_InitializeContext(NULL, context);
if (result != TEEC_SUCCESS) {
pr_err("InitializeContext failed, ReturnCode=0x%x\n", result);
goto cleanup_1;
} else {
sec_debug("InitializeContext success\n");
}
/* operation params create */
op.started = 1;
op.cancel_flag = 0;
/*open session*/
op.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE,
TEEC_NONE,
TEEC_MEMREF_TEMP_INPUT,
TEEC_MEMREF_TEMP_INPUT);
op.params[2].tmpref.buffer = (void *)&root_id;
op.params[2].tmpref.size = sizeof(root_id);
op.params[3].tmpref.buffer = (void *)package_name;
op.params[3].tmpref.size = (size_t)(strlen(package_name) + 1);
result = TEEK_OpenSession(context, session, &svc_id,
TEEC_LOGIN_IDENTIFY, NULL, &op, &origin);
if (result != TEEC_SUCCESS) {
pr_err("OpenSession fail, RC=0x%x, RO=0x%x\n", result, origin);
goto cleanup_2;
} else {
sec_debug("OpenSession success\n");
}
return 0;
cleanup_2:
TEEK_FinalizeContext(context);
cleanup_1:
return -EINVAL;
}
static void check_tee_return(u32 cmd, struct mem_chunk_list *mcl,
TEEC_Operation op)
{
if (cmd == ION_SEC_CMD_ALLOC) {
mcl->buff_id = op.params[1].value.b;
sec_debug("TEE return secbuf id 0x%x\n", mcl->buff_id);
}
if (cmd == ION_SEC_CMD_MAP_IOMMU) {
mcl->va = op.params[1].value.b;
sec_debug("TEE return iova 0x%x\n", mcl->va);
}
}
int secmem_tee_exec_cmd(TEEC_Session *session,
struct mem_chunk_list *mcl, u32 cmd)
{
TEEC_Result result;
TEEC_Operation op = {0};
u32 protect_id = SEC_TASK_MAX;
u32 origin = 0;
if (!session || !mcl)
return -EINVAL;
protect_id = mcl->protect_id;
op.started = 1;
op.cancel_flag = 0;
op.params[0].value.a = cmd;
op.params[0].value.b = protect_id;
switch (cmd) {
case ION_SEC_CMD_ALLOC:
op.paramTypes = TEEC_PARAM_TYPES(
TEEC_VALUE_INPUT,
TEEC_VALUE_INOUT,
TEEC_MEMREF_TEMP_INPUT,
TEEC_NONE);
op.params[1].value.a = mcl->nents;
/* op.params[1].value.b receive the return value*/
/* number of list in CMD buffer alloc/table set/table clean*/
op.params[2].tmpref.buffer = mcl->phys_addr;
op.params[2].tmpref.size =
mcl->nents * sizeof(struct tz_pageinfo);
break;
case ION_SEC_CMD_MAP_IOMMU:
op.paramTypes = TEEC_PARAM_TYPES(
TEEC_VALUE_INPUT,
TEEC_VALUE_INOUT,
TEEC_NONE,
TEEC_NONE);
op.params[1].value.a = mcl->buff_id;
op.params[1].value.b = mcl->size;
break;
case ION_SEC_CMD_FREE:
case ION_SEC_CMD_UNMAP_IOMMU:
op.paramTypes = TEEC_PARAM_TYPES(
TEEC_VALUE_INPUT,
TEEC_VALUE_INPUT,
TEEC_NONE,
TEEC_NONE);
op.params[1].value.a = mcl->buff_id;
break;
case ION_SEC_CMD_TABLE_SET:
case ION_SEC_CMD_TABLE_CLEAN:
op.paramTypes = TEEC_PARAM_TYPES(
TEEC_VALUE_INPUT,
TEEC_VALUE_INPUT,
TEEC_MEMREF_TEMP_INPUT,
TEEC_NONE);
op.params[1].value.a = mcl->nents;
op.params[2].tmpref.buffer = mcl->phys_addr;
op.params[2].tmpref.size =
mcl->nents * sizeof(struct tz_pageinfo);
break;
#ifdef CONFIG_SECMEM_TEST
case ION_SEC_CMD_TEST:
op.paramTypes = TEEC_PARAM_TYPES(
TEEC_VALUE_INPUT,
TEEC_VALUE_INPUT,
TEEC_MEMREF_TEMP_INPUT,
TEEC_NONE);
op.params[1].value.a = mcl->buff_id;
op.params[1].value.b = mcl->size;
op.params[2].tmpref.buffer = mcl->phys_addr;
op.params[2].tmpref.size =
mcl->nents * sizeof(struct tz_pageinfo);
break;
#endif
default:
pr_err("Invalid cmd\n");
return -EINVAL;
}
result = TEEK_InvokeCommand(session, SECBOOT_CMD_ID_MEM_ALLOCATE,
&op, &origin);
if (result != TEEC_SUCCESS) {
pr_err("Invoke CMD fail, RC=0x%x, RO=0x%x\n", result, origin);
return -EFAULT;
}
sec_debug("Exec TEE CMD success.\n");
check_tee_return(cmd, mcl, op);
return 0;
}
void secmem_tee_destroy(TEEC_Context *context, TEEC_Session *session)
{
if (!context || !session) {
pr_err("Invalid context or session\n");
return;
}
TEEK_CloseSession(session);
TEEK_FinalizeContext(context);
sec_debug("TA closed !\n");
}
|
830903.c | /*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
[email protected]
*/
#include "SDL_config.h"
#include "SDL_mouse.h"
#include "../../events/SDL_events_c.h"
#include "SDL_svgavideo.h"
#include "SDL_svgamouse_c.h"
/* The implementation dependent data for the window manager cursor */
struct WMcursor {
int unused;
};
|
2455.c | /*
* EAP-TNC - TNCC (IF-IMC and IF-TNCCS)
* Copyright (c) 2007, Jouni Malinen <[email protected]>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "includes.h"
#ifndef CONFIG_NATIVE_WINDOWS
#include <dlfcn.h>
#endif /* CONFIG_NATIVE_WINDOWS */
#include "common.h"
#include "base64.h"
#include "tncc.h"
#include "eap_common/eap_tlv_common.h"
#include "eap_common/eap_defs.h"
#ifdef UNICODE
#define TSTR "%S"
#else /* UNICODE */
#define TSTR "%s"
#endif /* UNICODE */
#define TNC_CONFIG_FILE "/etc/tnc_config"
#define TNC_WINREG_PATH TEXT("SOFTWARE\\Trusted Computing Group\\TNC\\IMCs")
#define IF_TNCCS_START \
"<?xml version=\"1.0\"?>\n" \
"<TNCCS-Batch BatchId=\"%d\" Recipient=\"TNCS\" " \
"xmlns=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/IF_TNCCS#\" " \
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " \
"xsi:schemaLocation=\"http://www.trustedcomputinggroup.org/IWG/TNC/1_0/" \
"IF_TNCCS# https://www.trustedcomputinggroup.org/XML/SCHEMA/TNCCS_1.0.xsd\">\n"
#define IF_TNCCS_END "\n</TNCCS-Batch>"
/* TNC IF-IMC */
typedef unsigned long TNC_UInt32;
typedef unsigned char *TNC_BufferReference;
typedef TNC_UInt32 TNC_IMCID;
typedef TNC_UInt32 TNC_ConnectionID;
typedef TNC_UInt32 TNC_ConnectionState;
typedef TNC_UInt32 TNC_RetryReason;
typedef TNC_UInt32 TNC_MessageType;
typedef TNC_MessageType *TNC_MessageTypeList;
typedef TNC_UInt32 TNC_VendorID;
typedef TNC_UInt32 TNC_MessageSubtype;
typedef TNC_UInt32 TNC_Version;
typedef TNC_UInt32 TNC_Result;
typedef TNC_Result (*TNC_TNCC_BindFunctionPointer)(
TNC_IMCID imcID,
char *functionName,
void **pOutfunctionPointer);
#define TNC_RESULT_SUCCESS 0
#define TNC_RESULT_NOT_INITIALIZED 1
#define TNC_RESULT_ALREADY_INITIALIZED 2
#define TNC_RESULT_NO_COMMON_VERSION 3
#define TNC_RESULT_CANT_RETRY 4
#define TNC_RESULT_WONT_RETRY 5
#define TNC_RESULT_INVALID_PARAMETER 6
#define TNC_RESULT_CANT_RESPOND 7
#define TNC_RESULT_ILLEGAL_OPERATION 8
#define TNC_RESULT_OTHER 9
#define TNC_RESULT_FATAL 10
#define TNC_CONNECTION_STATE_CREATE 0
#define TNC_CONNECTION_STATE_HANDSHAKE 1
#define TNC_CONNECTION_STATE_ACCESS_ALLOWED 2
#define TNC_CONNECTION_STATE_ACCESS_ISOLATED 3
#define TNC_CONNECTION_STATE_ACCESS_NONE 4
#define TNC_CONNECTION_STATE_DELETE 5
#define TNC_IFIMC_VERSION_1 1
#define TNC_VENDORID_ANY ((TNC_VendorID) 0xffffff)
#define TNC_SUBTYPE_ANY ((TNC_MessageSubtype) 0xff)
/* TNCC-TNCS Message Types */
#define TNC_TNCCS_RECOMMENDATION 0x00000001
#define TNC_TNCCS_ERROR 0x00000002
#define TNC_TNCCS_PREFERREDLANGUAGE 0x00000003
#define TNC_TNCCS_REASONSTRINGS 0x00000004
/* IF-TNCCS-SOH - SSoH and SSoHR Attributes */
enum {
SSOH_MS_MACHINE_INVENTORY = 1,
SSOH_MS_QUARANTINE_STATE = 2,
SSOH_MS_PACKET_INFO = 3,
SSOH_MS_SYSTEMGENERATED_IDS = 4,
SSOH_MS_MACHINENAME = 5,
SSOH_MS_CORRELATIONID = 6,
SSOH_MS_INSTALLED_SHVS = 7,
SSOH_MS_MACHINE_INVENTORY_EX = 8
};
struct tnc_if_imc {
struct tnc_if_imc *next;
char *name;
char *path;
void *dlhandle; /* from dlopen() */
TNC_IMCID imcID;
TNC_ConnectionID connectionID;
TNC_MessageTypeList supported_types;
size_t num_supported_types;
u8 *imc_send;
size_t imc_send_len;
/* Functions implemented by IMCs (with TNC_IMC_ prefix) */
TNC_Result (*Initialize)(
TNC_IMCID imcID,
TNC_Version minVersion,
TNC_Version maxVersion,
TNC_Version *pOutActualVersion);
TNC_Result (*NotifyConnectionChange)(
TNC_IMCID imcID,
TNC_ConnectionID connectionID,
TNC_ConnectionState newState);
TNC_Result (*BeginHandshake)(
TNC_IMCID imcID,
TNC_ConnectionID connectionID);
TNC_Result (*ReceiveMessage)(
TNC_IMCID imcID,
TNC_ConnectionID connectionID,
TNC_BufferReference messageBuffer,
TNC_UInt32 messageLength,
TNC_MessageType messageType);
TNC_Result (*BatchEnding)(
TNC_IMCID imcID,
TNC_ConnectionID connectionID);
TNC_Result (*Terminate)(TNC_IMCID imcID);
TNC_Result (*ProvideBindFunction)(
TNC_IMCID imcID,
TNC_TNCC_BindFunctionPointer bindFunction);
};
struct tncc_data {
struct tnc_if_imc *imc;
unsigned int last_batchid;
};
#define TNC_MAX_IMC_ID 10
static struct tnc_if_imc *tnc_imc[TNC_MAX_IMC_ID] = { NULL };
/* TNCC functions that IMCs can call */
TNC_Result TNC_TNCC_ReportMessageTypes(
TNC_IMCID imcID,
TNC_MessageTypeList supportedTypes,
TNC_UInt32 typeCount)
{
TNC_UInt32 i;
struct tnc_if_imc *imc;
wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_ReportMessageTypes(imcID=%lu "
"typeCount=%lu)",
(unsigned long) imcID, (unsigned long) typeCount);
for (i = 0; i < typeCount; i++) {
wpa_printf(MSG_DEBUG, "TNC: supportedTypes[%lu] = %lu",
i, supportedTypes[i]);
}
if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL)
return TNC_RESULT_INVALID_PARAMETER;
imc = tnc_imc[imcID];
os_free(imc->supported_types);
imc->supported_types =
os_malloc(typeCount * sizeof(TNC_MessageType));
if (imc->supported_types == NULL)
return TNC_RESULT_FATAL;
os_memcpy(imc->supported_types, supportedTypes,
typeCount * sizeof(TNC_MessageType));
imc->num_supported_types = typeCount;
return TNC_RESULT_SUCCESS;
}
TNC_Result TNC_TNCC_SendMessage(
TNC_IMCID imcID,
TNC_ConnectionID connectionID,
TNC_BufferReference message,
TNC_UInt32 messageLength,
TNC_MessageType messageType)
{
struct tnc_if_imc *imc;
unsigned char *b64;
size_t b64len;
wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_SendMessage(imcID=%lu "
"connectionID=%lu messageType=%lu)",
imcID, connectionID, messageType);
wpa_hexdump_ascii(MSG_DEBUG, "TNC: TNC_TNCC_SendMessage",
message, messageLength);
if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL)
return TNC_RESULT_INVALID_PARAMETER;
b64 = base64_encode(message, messageLength, &b64len);
if (b64 == NULL)
return TNC_RESULT_FATAL;
imc = tnc_imc[imcID];
os_free(imc->imc_send);
imc->imc_send_len = 0;
imc->imc_send = os_zalloc(b64len + 100);
if (imc->imc_send == NULL) {
os_free(b64);
return TNC_RESULT_OTHER;
}
imc->imc_send_len =
os_snprintf((char *) imc->imc_send, b64len + 100,
"<IMC-IMV-Message><Type>%08X</Type>"
"<Base64>%s</Base64></IMC-IMV-Message>",
(unsigned int) messageType, b64);
os_free(b64);
return TNC_RESULT_SUCCESS;
}
TNC_Result TNC_TNCC_RequestHandshakeRetry(
TNC_IMCID imcID,
TNC_ConnectionID connectionID,
TNC_RetryReason reason)
{
wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_RequestHandshakeRetry");
if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL)
return TNC_RESULT_INVALID_PARAMETER;
/*
* TODO: trigger a call to eapol_sm_request_reauth(). This would
* require that the IMC continues to be loaded in memory afer
* authentication..
*/
return TNC_RESULT_SUCCESS;
}
TNC_Result TNC_9048_LogMessage(TNC_IMCID imcID, TNC_UInt32 severity,
const char *message)
{
wpa_printf(MSG_DEBUG, "TNC: TNC_9048_LogMessage(imcID=%lu "
"severity==%lu message='%s')",
imcID, severity, message);
return TNC_RESULT_SUCCESS;
}
TNC_Result TNC_9048_UserMessage(TNC_IMCID imcID, TNC_ConnectionID connectionID,
const char *message)
{
wpa_printf(MSG_DEBUG, "TNC: TNC_9048_UserMessage(imcID=%lu "
"connectionID==%lu message='%s')",
imcID, connectionID, message);
return TNC_RESULT_SUCCESS;
}
TNC_Result TNC_TNCC_BindFunction(
TNC_IMCID imcID,
char *functionName,
void **pOutfunctionPointer)
{
wpa_printf(MSG_DEBUG, "TNC: TNC_TNCC_BindFunction(imcID=%lu, "
"functionName='%s')", (unsigned long) imcID, functionName);
if (imcID >= TNC_MAX_IMC_ID || tnc_imc[imcID] == NULL)
return TNC_RESULT_INVALID_PARAMETER;
if (pOutfunctionPointer == NULL)
return TNC_RESULT_INVALID_PARAMETER;
if (os_strcmp(functionName, "TNC_TNCC_ReportMessageTypes") == 0)
*pOutfunctionPointer = TNC_TNCC_ReportMessageTypes;
else if (os_strcmp(functionName, "TNC_TNCC_SendMessage") == 0)
*pOutfunctionPointer = TNC_TNCC_SendMessage;
else if (os_strcmp(functionName, "TNC_TNCC_RequestHandshakeRetry") ==
0)
*pOutfunctionPointer = TNC_TNCC_RequestHandshakeRetry;
else if (os_strcmp(functionName, "TNC_9048_LogMessage") == 0)
*pOutfunctionPointer = TNC_9048_LogMessage;
else if (os_strcmp(functionName, "TNC_9048_UserMessage") == 0)
*pOutfunctionPointer = TNC_9048_UserMessage;
else
*pOutfunctionPointer = NULL;
return TNC_RESULT_SUCCESS;
}
static void * tncc_get_sym(void *handle, char *func)
{
void *fptr;
#ifdef CONFIG_NATIVE_WINDOWS
#ifdef _WIN32_WCE
fptr = GetProcAddressA(handle, func);
#else /* _WIN32_WCE */
fptr = GetProcAddress(handle, func);
#endif /* _WIN32_WCE */
#else /* CONFIG_NATIVE_WINDOWS */
fptr = dlsym(handle, func);
#endif /* CONFIG_NATIVE_WINDOWS */
return fptr;
}
static int tncc_imc_resolve_funcs(struct tnc_if_imc *imc)
{
void *handle = imc->dlhandle;
/* Mandatory IMC functions */
imc->Initialize = tncc_get_sym(handle, "TNC_IMC_Initialize");
if (imc->Initialize == NULL) {
wpa_printf(MSG_ERROR, "TNC: IMC does not export "
"TNC_IMC_Initialize");
return -1;
}
imc->BeginHandshake = tncc_get_sym(handle, "TNC_IMC_BeginHandshake");
if (imc->BeginHandshake == NULL) {
wpa_printf(MSG_ERROR, "TNC: IMC does not export "
"TNC_IMC_BeginHandshake");
return -1;
}
imc->ProvideBindFunction =
tncc_get_sym(handle, "TNC_IMC_ProvideBindFunction");
if (imc->ProvideBindFunction == NULL) {
wpa_printf(MSG_ERROR, "TNC: IMC does not export "
"TNC_IMC_ProvideBindFunction");
return -1;
}
/* Optional IMC functions */
imc->NotifyConnectionChange =
tncc_get_sym(handle, "TNC_IMC_NotifyConnectionChange");
imc->ReceiveMessage = tncc_get_sym(handle, "TNC_IMC_ReceiveMessage");
imc->BatchEnding = tncc_get_sym(handle, "TNC_IMC_BatchEnding");
imc->Terminate = tncc_get_sym(handle, "TNC_IMC_Terminate");
return 0;
}
static int tncc_imc_initialize(struct tnc_if_imc *imc)
{
TNC_Result res;
TNC_Version imc_ver;
wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_Initialize for IMC '%s'",
imc->name);
res = imc->Initialize(imc->imcID, TNC_IFIMC_VERSION_1,
TNC_IFIMC_VERSION_1, &imc_ver);
wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_Initialize: res=%lu imc_ver=%lu",
(unsigned long) res, (unsigned long) imc_ver);
return res == TNC_RESULT_SUCCESS ? 0 : -1;
}
static int tncc_imc_terminate(struct tnc_if_imc *imc)
{
TNC_Result res;
if (imc->Terminate == NULL)
return 0;
wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_Terminate for IMC '%s'",
imc->name);
res = imc->Terminate(imc->imcID);
wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_Terminate: %lu",
(unsigned long) res);
return res == TNC_RESULT_SUCCESS ? 0 : -1;
}
static int tncc_imc_provide_bind_function(struct tnc_if_imc *imc)
{
TNC_Result res;
wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_ProvideBindFunction for "
"IMC '%s'", imc->name);
res = imc->ProvideBindFunction(imc->imcID, TNC_TNCC_BindFunction);
wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_ProvideBindFunction: res=%lu",
(unsigned long) res);
return res == TNC_RESULT_SUCCESS ? 0 : -1;
}
static int tncc_imc_notify_connection_change(struct tnc_if_imc *imc,
TNC_ConnectionState state)
{
TNC_Result res;
if (imc->NotifyConnectionChange == NULL)
return 0;
wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_NotifyConnectionChange(%d)"
" for IMC '%s'", (int) state, imc->name);
res = imc->NotifyConnectionChange(imc->imcID, imc->connectionID,
state);
wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_NotifyConnectionChange: %lu",
(unsigned long) res);
return res == TNC_RESULT_SUCCESS ? 0 : -1;
}
static int tncc_imc_begin_handshake(struct tnc_if_imc *imc)
{
TNC_Result res;
wpa_printf(MSG_DEBUG, "TNC: Calling TNC_IMC_BeginHandshake for IMC "
"'%s'", imc->name);
res = imc->BeginHandshake(imc->imcID, imc->connectionID);
wpa_printf(MSG_DEBUG, "TNC: TNC_IMC_BeginHandshake: %lu",
(unsigned long) res);
return res == TNC_RESULT_SUCCESS ? 0 : -1;
}
static int tncc_load_imc(struct tnc_if_imc *imc)
{
if (imc->path == NULL) {
wpa_printf(MSG_DEBUG, "TNC: No IMC configured");
return -1;
}
wpa_printf(MSG_DEBUG, "TNC: Opening IMC: %s (%s)",
imc->name, imc->path);
#ifdef CONFIG_NATIVE_WINDOWS
#ifdef UNICODE
{
TCHAR *lib = wpa_strdup_tchar(imc->path);
if (lib == NULL)
return -1;
imc->dlhandle = LoadLibrary(lib);
os_free(lib);
}
#else /* UNICODE */
imc->dlhandle = LoadLibrary(imc->path);
#endif /* UNICODE */
if (imc->dlhandle == NULL) {
wpa_printf(MSG_ERROR, "TNC: Failed to open IMC '%s' (%s): %d",
imc->name, imc->path, (int) GetLastError());
return -1;
}
#else /* CONFIG_NATIVE_WINDOWS */
imc->dlhandle = dlopen(imc->path, RTLD_LAZY);
if (imc->dlhandle == NULL) {
wpa_printf(MSG_ERROR, "TNC: Failed to open IMC '%s' (%s): %s",
imc->name, imc->path, dlerror());
return -1;
}
#endif /* CONFIG_NATIVE_WINDOWS */
if (tncc_imc_resolve_funcs(imc) < 0) {
wpa_printf(MSG_ERROR, "TNC: Failed to resolve IMC functions");
return -1;
}
if (tncc_imc_initialize(imc) < 0 ||
tncc_imc_provide_bind_function(imc) < 0) {
wpa_printf(MSG_ERROR, "TNC: Failed to initialize IMC");
return -1;
}
return 0;
}
static void tncc_unload_imc(struct tnc_if_imc *imc)
{
tncc_imc_terminate(imc);
tnc_imc[imc->imcID] = NULL;
if (imc->dlhandle) {
#ifdef CONFIG_NATIVE_WINDOWS
FreeLibrary(imc->dlhandle);
#else /* CONFIG_NATIVE_WINDOWS */
dlclose(imc->dlhandle);
#endif /* CONFIG_NATIVE_WINDOWS */
}
os_free(imc->name);
os_free(imc->path);
os_free(imc->supported_types);
os_free(imc->imc_send);
}
static int tncc_supported_type(struct tnc_if_imc *imc, unsigned int type)
{
size_t i;
unsigned int vendor, subtype;
if (imc == NULL || imc->supported_types == NULL)
return 0;
vendor = type >> 8;
subtype = type & 0xff;
for (i = 0; i < imc->num_supported_types; i++) {
unsigned int svendor, ssubtype;
svendor = imc->supported_types[i] >> 8;
ssubtype = imc->supported_types[i] & 0xff;
if ((vendor == svendor || svendor == TNC_VENDORID_ANY) &&
(subtype == ssubtype || ssubtype == TNC_SUBTYPE_ANY))
return 1;
}
return 0;
}
static void tncc_send_to_imcs(struct tncc_data *tncc, unsigned int type,
const u8 *msg, size_t len)
{
struct tnc_if_imc *imc;
TNC_Result res;
wpa_hexdump_ascii(MSG_MSGDUMP, "TNC: Message to IMC(s)", msg, len);
for (imc = tncc->imc; imc; imc = imc->next) {
if (imc->ReceiveMessage == NULL ||
!tncc_supported_type(imc, type))
continue;
wpa_printf(MSG_DEBUG, "TNC: Call ReceiveMessage for IMC '%s'",
imc->name);
res = imc->ReceiveMessage(imc->imcID, imc->connectionID,
(TNC_BufferReference) msg, len,
type);
wpa_printf(MSG_DEBUG, "TNC: ReceiveMessage: %lu",
(unsigned long) res);
}
}
void tncc_init_connection(struct tncc_data *tncc)
{
struct tnc_if_imc *imc;
for (imc = tncc->imc; imc; imc = imc->next) {
tncc_imc_notify_connection_change(
imc, TNC_CONNECTION_STATE_CREATE);
tncc_imc_notify_connection_change(
imc, TNC_CONNECTION_STATE_HANDSHAKE);
os_free(imc->imc_send);
imc->imc_send = NULL;
imc->imc_send_len = 0;
tncc_imc_begin_handshake(imc);
}
}
size_t tncc_total_send_len(struct tncc_data *tncc)
{
struct tnc_if_imc *imc;
size_t len = 0;
for (imc = tncc->imc; imc; imc = imc->next)
len += imc->imc_send_len;
return len;
}
u8 * tncc_copy_send_buf(struct tncc_data *tncc, u8 *pos)
{
struct tnc_if_imc *imc;
for (imc = tncc->imc; imc; imc = imc->next) {
if (imc->imc_send == NULL)
continue;
os_memcpy(pos, imc->imc_send, imc->imc_send_len);
pos += imc->imc_send_len;
os_free(imc->imc_send);
imc->imc_send = NULL;
imc->imc_send_len = 0;
}
return pos;
}
char * tncc_if_tnccs_start(struct tncc_data *tncc)
{
char *buf = os_malloc(1000);
if (buf == NULL)
return NULL;
tncc->last_batchid++;
os_snprintf(buf, 1000, IF_TNCCS_START, tncc->last_batchid);
return buf;
}
char * tncc_if_tnccs_end(void)
{
char *buf = os_malloc(100);
if (buf == NULL)
return NULL;
os_snprintf(buf, 100, IF_TNCCS_END);
return buf;
}
static void tncc_notify_recommendation(struct tncc_data *tncc,
enum tncc_process_res res)
{
TNC_ConnectionState state;
struct tnc_if_imc *imc;
switch (res) {
case TNCCS_RECOMMENDATION_ALLOW:
state = TNC_CONNECTION_STATE_ACCESS_ALLOWED;
break;
case TNCCS_RECOMMENDATION_NONE:
state = TNC_CONNECTION_STATE_ACCESS_NONE;
break;
case TNCCS_RECOMMENDATION_ISOLATE:
state = TNC_CONNECTION_STATE_ACCESS_ISOLATED;
break;
default:
state = TNC_CONNECTION_STATE_ACCESS_NONE;
break;
}
for (imc = tncc->imc; imc; imc = imc->next)
tncc_imc_notify_connection_change(imc, state);
}
static int tncc_get_type(char *start, unsigned int *type)
{
char *pos = os_strstr(start, "<Type>");
if (pos == NULL)
return -1;
pos += 6;
*type = strtoul(pos, NULL, 16);
return 0;
}
static unsigned char * tncc_get_base64(char *start, size_t *decoded_len)
{
char *pos, *pos2;
unsigned char *decoded;
pos = os_strstr(start, "<Base64>");
if (pos == NULL)
return NULL;
pos += 8;
pos2 = os_strstr(pos, "</Base64>");
if (pos2 == NULL)
return NULL;
*pos2 = '\0';
decoded = base64_decode((unsigned char *) pos, os_strlen(pos),
decoded_len);
*pos2 = '<';
if (decoded == NULL) {
wpa_printf(MSG_DEBUG, "TNC: Failed to decode Base64 data");
}
return decoded;
}
static enum tncc_process_res tncc_get_recommendation(char *start)
{
char *pos, *pos2, saved;
int recom;
pos = os_strstr(start, "<TNCCS-Recommendation ");
if (pos == NULL)
return TNCCS_RECOMMENDATION_ERROR;
pos += 21;
pos = os_strstr(pos, " type=");
if (pos == NULL)
return TNCCS_RECOMMENDATION_ERROR;
pos += 6;
if (*pos == '"')
pos++;
pos2 = pos;
while (*pos2 != '\0' && *pos2 != '"' && *pos2 != '>')
pos2++;
if (*pos2 == '\0')
return TNCCS_RECOMMENDATION_ERROR;
saved = *pos2;
*pos2 = '\0';
wpa_printf(MSG_DEBUG, "TNC: TNCCS-Recommendation: '%s'", pos);
recom = TNCCS_RECOMMENDATION_ERROR;
if (os_strcmp(pos, "allow") == 0)
recom = TNCCS_RECOMMENDATION_ALLOW;
else if (os_strcmp(pos, "none") == 0)
recom = TNCCS_RECOMMENDATION_NONE;
else if (os_strcmp(pos, "isolate") == 0)
recom = TNCCS_RECOMMENDATION_ISOLATE;
*pos2 = saved;
return recom;
}
enum tncc_process_res tncc_process_if_tnccs(struct tncc_data *tncc,
const u8 *msg, size_t len)
{
char *buf, *start, *end, *pos, *pos2, *payload;
unsigned int batch_id;
unsigned char *decoded;
size_t decoded_len;
enum tncc_process_res res = TNCCS_PROCESS_OK_NO_RECOMMENDATION;
int recommendation_msg = 0;
buf = os_malloc(len + 1);
if (buf == NULL)
return TNCCS_PROCESS_ERROR;
os_memcpy(buf, msg, len);
buf[len] = '\0';
start = os_strstr(buf, "<TNCCS-Batch ");
end = os_strstr(buf, "</TNCCS-Batch>");
if (start == NULL || end == NULL || start > end) {
os_free(buf);
return TNCCS_PROCESS_ERROR;
}
start += 13;
while (*start == ' ')
start++;
*end = '\0';
pos = os_strstr(start, "BatchId=");
if (pos == NULL) {
os_free(buf);
return TNCCS_PROCESS_ERROR;
}
pos += 8;
if (*pos == '"')
pos++;
batch_id = atoi(pos);
wpa_printf(MSG_DEBUG, "TNC: Received IF-TNCCS BatchId=%u",
batch_id);
if (batch_id != tncc->last_batchid + 1) {
wpa_printf(MSG_DEBUG, "TNC: Unexpected IF-TNCCS BatchId "
"%u (expected %u)",
batch_id, tncc->last_batchid + 1);
os_free(buf);
return TNCCS_PROCESS_ERROR;
}
tncc->last_batchid = batch_id;
while (*pos != '\0' && *pos != '>')
pos++;
if (*pos == '\0') {
os_free(buf);
return TNCCS_PROCESS_ERROR;
}
pos++;
payload = start;
/*
* <IMC-IMV-Message>
* <Type>01234567</Type>
* <Base64>foo==</Base64>
* </IMC-IMV-Message>
*/
while (*start) {
char *endpos;
unsigned int type;
pos = os_strstr(start, "<IMC-IMV-Message>");
if (pos == NULL)
break;
start = pos + 17;
end = os_strstr(start, "</IMC-IMV-Message>");
if (end == NULL)
break;
*end = '\0';
endpos = end;
end += 18;
if (tncc_get_type(start, &type) < 0) {
*endpos = '<';
start = end;
continue;
}
wpa_printf(MSG_DEBUG, "TNC: IMC-IMV-Message Type 0x%x", type);
decoded = tncc_get_base64(start, &decoded_len);
if (decoded == NULL) {
*endpos = '<';
start = end;
continue;
}
tncc_send_to_imcs(tncc, type, decoded, decoded_len);
os_free(decoded);
start = end;
}
/*
* <TNCC-TNCS-Message>
* <Type>01234567</Type>
* <XML><TNCCS-Foo type="foo"></TNCCS-Foo></XML>
* <Base64>foo==</Base64>
* </TNCC-TNCS-Message>
*/
start = payload;
while (*start) {
unsigned int type;
char *xml, *xmlend, *endpos;
pos = os_strstr(start, "<TNCC-TNCS-Message>");
if (pos == NULL)
break;
start = pos + 19;
end = os_strstr(start, "</TNCC-TNCS-Message>");
if (end == NULL)
break;
*end = '\0';
endpos = end;
end += 20;
if (tncc_get_type(start, &type) < 0) {
*endpos = '<';
start = end;
continue;
}
wpa_printf(MSG_DEBUG, "TNC: TNCC-TNCS-Message Type 0x%x",
type);
/* Base64 OR XML */
decoded = NULL;
xml = NULL;
xmlend = NULL;
pos = os_strstr(start, "<XML>");
if (pos) {
pos += 5;
pos2 = os_strstr(pos, "</XML>");
if (pos2 == NULL) {
*endpos = '<';
start = end;
continue;
}
xmlend = pos2;
xml = pos;
} else {
decoded = tncc_get_base64(start, &decoded_len);
if (decoded == NULL) {
*endpos = '<';
start = end;
continue;
}
}
if (decoded) {
wpa_hexdump_ascii(MSG_MSGDUMP,
"TNC: TNCC-TNCS-Message Base64",
decoded, decoded_len);
os_free(decoded);
}
if (xml) {
wpa_hexdump_ascii(MSG_MSGDUMP,
"TNC: TNCC-TNCS-Message XML",
(unsigned char *) xml,
xmlend - xml);
}
if (type == TNC_TNCCS_RECOMMENDATION && xml) {
/*
* <TNCCS-Recommendation type="allow">
* </TNCCS-Recommendation>
*/
*xmlend = '\0';
res = tncc_get_recommendation(xml);
*xmlend = '<';
recommendation_msg = 1;
}
start = end;
}
os_free(buf);
if (recommendation_msg)
tncc_notify_recommendation(tncc, res);
return res;
}
#ifdef CONFIG_NATIVE_WINDOWS
static int tncc_read_config_reg(struct tncc_data *tncc, HKEY hive)
{
HKEY hk, hk2;
LONG ret;
DWORD i;
struct tnc_if_imc *imc, *last;
int j;
last = tncc->imc;
while (last && last->next)
last = last->next;
ret = RegOpenKeyEx(hive, TNC_WINREG_PATH, 0, KEY_ENUMERATE_SUB_KEYS,
&hk);
if (ret != ERROR_SUCCESS)
return 0;
for (i = 0; ; i++) {
TCHAR name[255], *val;
DWORD namelen, buflen;
namelen = 255;
ret = RegEnumKeyEx(hk, i, name, &namelen, NULL, NULL, NULL,
NULL);
if (ret == ERROR_NO_MORE_ITEMS)
break;
if (ret != ERROR_SUCCESS) {
wpa_printf(MSG_DEBUG, "TNC: RegEnumKeyEx failed: 0x%x",
(unsigned int) ret);
break;
}
if (namelen >= 255)
namelen = 255 - 1;
name[namelen] = '\0';
wpa_printf(MSG_DEBUG, "TNC: IMC '" TSTR "'", name);
ret = RegOpenKeyEx(hk, name, 0, KEY_QUERY_VALUE, &hk2);
if (ret != ERROR_SUCCESS) {
wpa_printf(MSG_DEBUG, "Could not open IMC key '" TSTR
"'", name);
continue;
}
ret = RegQueryValueEx(hk2, TEXT("Path"), NULL, NULL, NULL,
&buflen);
if (ret != ERROR_SUCCESS) {
wpa_printf(MSG_DEBUG, "TNC: Could not read Path from "
"IMC key '" TSTR "'", name);
RegCloseKey(hk2);
continue;
}
val = os_malloc(buflen);
if (val == NULL) {
RegCloseKey(hk2);
continue;
}
ret = RegQueryValueEx(hk2, TEXT("Path"), NULL, NULL,
(LPBYTE) val, &buflen);
if (ret != ERROR_SUCCESS) {
os_free(val);
RegCloseKey(hk2);
continue;
}
RegCloseKey(hk2);
wpa_unicode2ascii_inplace(val);
wpa_printf(MSG_DEBUG, "TNC: IMC Path '%s'", (char *) val);
for (j = 0; j < TNC_MAX_IMC_ID; j++) {
if (tnc_imc[j] == NULL)
break;
}
if (j >= TNC_MAX_IMC_ID) {
wpa_printf(MSG_DEBUG, "TNC: Too many IMCs");
os_free(val);
continue;
}
imc = os_zalloc(sizeof(*imc));
if (imc == NULL) {
os_free(val);
break;
}
imc->imcID = j;
wpa_unicode2ascii_inplace(name);
imc->name = os_strdup((char *) name);
imc->path = os_strdup((char *) val);
os_free(val);
if (last == NULL)
tncc->imc = imc;
else
last->next = imc;
last = imc;
tnc_imc[imc->imcID] = imc;
}
RegCloseKey(hk);
return 0;
}
static int tncc_read_config(struct tncc_data *tncc)
{
if (tncc_read_config_reg(tncc, HKEY_LOCAL_MACHINE) < 0 ||
tncc_read_config_reg(tncc, HKEY_CURRENT_USER) < 0)
return -1;
return 0;
}
#else /* CONFIG_NATIVE_WINDOWS */
static struct tnc_if_imc * tncc_parse_imc(char *start, char *end, int *error)
{
struct tnc_if_imc *imc;
char *pos, *pos2;
int i;
for (i = 0; i < TNC_MAX_IMC_ID; i++) {
if (tnc_imc[i] == NULL)
break;
}
if (i >= TNC_MAX_IMC_ID) {
wpa_printf(MSG_DEBUG, "TNC: Too many IMCs");
return NULL;
}
imc = os_zalloc(sizeof(*imc));
if (imc == NULL) {
*error = 1;
return NULL;
}
imc->imcID = i;
pos = start;
wpa_printf(MSG_DEBUG, "TNC: Configured IMC: %s", pos);
if (pos + 1 >= end || *pos != '"') {
wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' "
"(no starting quotation mark)", start);
os_free(imc);
return NULL;
}
pos++;
pos2 = pos;
while (pos2 < end && *pos2 != '"')
pos2++;
if (pos2 >= end) {
wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' "
"(no ending quotation mark)", start);
os_free(imc);
return NULL;
}
*pos2 = '\0';
wpa_printf(MSG_DEBUG, "TNC: Name: '%s'", pos);
imc->name = os_strdup(pos);
pos = pos2 + 1;
if (pos >= end || *pos != ' ') {
wpa_printf(MSG_ERROR, "TNC: Ignoring invalid IMC line '%s' "
"(no space after name)", start);
os_free(imc->name);
os_free(imc);
return NULL;
}
pos++;
wpa_printf(MSG_DEBUG, "TNC: IMC file: '%s'", pos);
imc->path = os_strdup(pos);
tnc_imc[imc->imcID] = imc;
return imc;
}
static int tncc_read_config(struct tncc_data *tncc)
{
char *config, *end, *pos, *line_end;
size_t config_len;
struct tnc_if_imc *imc, *last;
last = NULL;
config = os_readfile(TNC_CONFIG_FILE, &config_len);
if (config == NULL) {
wpa_printf(MSG_ERROR, "TNC: Could not open TNC configuration "
"file '%s'", TNC_CONFIG_FILE);
return -1;
}
end = config + config_len;
for (pos = config; pos < end; pos = line_end + 1) {
line_end = pos;
while (*line_end != '\n' && *line_end != '\r' &&
line_end < end)
line_end++;
*line_end = '\0';
if (os_strncmp(pos, "IMC ", 4) == 0) {
int error = 0;
imc = tncc_parse_imc(pos + 4, line_end, &error);
if (error)
return -1;
if (imc) {
if (last == NULL)
tncc->imc = imc;
else
last->next = imc;
last = imc;
}
}
}
os_free(config);
return 0;
}
#endif /* CONFIG_NATIVE_WINDOWS */
struct tncc_data * tncc_init(void)
{
struct tncc_data *tncc;
struct tnc_if_imc *imc;
tncc = os_zalloc(sizeof(*tncc));
if (tncc == NULL)
return NULL;
/* TODO:
* move loading and Initialize() to a location that is not
* re-initialized for every EAP-TNC session (?)
*/
if (tncc_read_config(tncc) < 0) {
wpa_printf(MSG_ERROR, "TNC: Failed to read TNC configuration");
goto failed;
}
for (imc = tncc->imc; imc; imc = imc->next) {
if (tncc_load_imc(imc)) {
wpa_printf(MSG_ERROR, "TNC: Failed to load IMC '%s'",
imc->name);
goto failed;
}
}
return tncc;
failed:
tncc_deinit(tncc);
return NULL;
}
void tncc_deinit(struct tncc_data *tncc)
{
struct tnc_if_imc *imc, *prev;
imc = tncc->imc;
while (imc) {
tncc_unload_imc(imc);
prev = imc;
imc = imc->next;
os_free(prev);
}
os_free(tncc);
}
static struct wpabuf * tncc_build_soh(int ver)
{
struct wpabuf *buf;
u8 *tlv_len, *tlv_len2, *outer_len, *inner_len, *ssoh_len, *end;
u8 correlation_id[24];
/* TODO: get correct name */
char *machinename = "[email protected]";
if (os_get_random(correlation_id, sizeof(correlation_id)))
return NULL;
wpa_hexdump(MSG_DEBUG, "TNC: SoH Correlation ID",
correlation_id, sizeof(correlation_id));
buf = wpabuf_alloc(200);
if (buf == NULL)
return NULL;
/* Vendor-Specific TLV (Microsoft) - SoH */
wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); /* TLV Type */
tlv_len = wpabuf_put(buf, 2); /* Length */
wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* Vendor_Id */
wpabuf_put_be16(buf, 0x01); /* TLV Type - SoH TLV */
tlv_len2 = wpabuf_put(buf, 2); /* Length */
/* SoH Header */
wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV); /* Outer Type */
outer_len = wpabuf_put(buf, 2);
wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */
wpabuf_put_be16(buf, ver); /* Inner Type */
inner_len = wpabuf_put(buf, 2);
if (ver == 2) {
/* SoH Mode Sub-Header */
/* Outer Type */
wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV);
wpabuf_put_be16(buf, 4 + 24 + 1 + 1); /* Length */
wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */
/* Value: */
wpabuf_put_data(buf, correlation_id, sizeof(correlation_id));
wpabuf_put_u8(buf, 0x01); /* Intent Flag - Request */
wpabuf_put_u8(buf, 0x00); /* Content-Type Flag */
}
/* SSoH TLV */
/* System-Health-Id */
wpabuf_put_be16(buf, 0x0002); /* Type */
wpabuf_put_be16(buf, 4); /* Length */
wpabuf_put_be32(buf, 79616);
/* Vendor-Specific Attribute */
wpabuf_put_be16(buf, EAP_TLV_VENDOR_SPECIFIC_TLV);
ssoh_len = wpabuf_put(buf, 2);
wpabuf_put_be32(buf, EAP_VENDOR_MICROSOFT); /* IANA SMI Code */
/* MS-Packet-Info */
wpabuf_put_u8(buf, SSOH_MS_PACKET_INFO);
/* Note: IF-TNCCS-SOH v1.0 r8 claims this field to be:
* Reserved(4 bits) r(1 bit) Vers(3 bits), but Windows XP
* SP3 seems to be sending 0x11 for SSoH, i.e., r(request/response) bit
* would not be in the specified location.
* [MS-SOH] 4.0.2: Reserved(3 bits) r(1 bit) Vers(4 bits)
*/
wpabuf_put_u8(buf, 0x11); /* r=request, vers=1 */
/* MS-Machine-Inventory */
/* TODO: get correct values; 0 = not applicable for OS */
wpabuf_put_u8(buf, SSOH_MS_MACHINE_INVENTORY);
wpabuf_put_be32(buf, 0); /* osVersionMajor */
wpabuf_put_be32(buf, 0); /* osVersionMinor */
wpabuf_put_be32(buf, 0); /* osVersionBuild */
wpabuf_put_be16(buf, 0); /* spVersionMajor */
wpabuf_put_be16(buf, 0); /* spVersionMinor */
wpabuf_put_be16(buf, 0); /* procArch */
/* MS-MachineName */
wpabuf_put_u8(buf, SSOH_MS_MACHINENAME);
wpabuf_put_be16(buf, os_strlen(machinename) + 1);
wpabuf_put_data(buf, machinename, os_strlen(machinename) + 1);
/* MS-CorrelationId */
wpabuf_put_u8(buf, SSOH_MS_CORRELATIONID);
wpabuf_put_data(buf, correlation_id, sizeof(correlation_id));
/* MS-Quarantine-State */
wpabuf_put_u8(buf, SSOH_MS_QUARANTINE_STATE);
wpabuf_put_be16(buf, 1); /* Flags: ExtState=0, f=0, qState=1 */
wpabuf_put_be32(buf, 0xffffffff); /* ProbTime (hi) */
wpabuf_put_be32(buf, 0xffffffff); /* ProbTime (lo) */
wpabuf_put_be16(buf, 1); /* urlLenInBytes */
wpabuf_put_u8(buf, 0); /* null termination for the url */
/* MS-Machine-Inventory-Ex */
wpabuf_put_u8(buf, SSOH_MS_MACHINE_INVENTORY_EX);
wpabuf_put_be32(buf, 0); /* Reserved
* (note: Windows XP SP3 uses 0xdecafbad) */
wpabuf_put_u8(buf, 1); /* ProductType: Client */
/* Update SSoH Length */
end = wpabuf_put(buf, 0);
WPA_PUT_BE16(ssoh_len, end - ssoh_len - 2);
/* TODO: SoHReportEntry TLV (zero or more) */
/* Update length fields */
end = wpabuf_put(buf, 0);
WPA_PUT_BE16(tlv_len, end - tlv_len - 2);
WPA_PUT_BE16(tlv_len2, end - tlv_len2 - 2);
WPA_PUT_BE16(outer_len, end - outer_len - 2);
WPA_PUT_BE16(inner_len, end - inner_len - 2);
return buf;
}
struct wpabuf * tncc_process_soh_request(int ver, const u8 *data, size_t len)
{
const u8 *pos;
wpa_hexdump(MSG_DEBUG, "TNC: SoH Request", data, len);
if (len < 12)
return NULL;
/* SoH Request */
pos = data;
/* TLV Type */
if (WPA_GET_BE16(pos) != EAP_TLV_VENDOR_SPECIFIC_TLV)
return NULL;
pos += 2;
/* Length */
if (WPA_GET_BE16(pos) < 8)
return NULL;
pos += 2;
/* Vendor_Id */
if (WPA_GET_BE32(pos) != EAP_VENDOR_MICROSOFT)
return NULL;
pos += 4;
/* TLV Type */
if (WPA_GET_BE16(pos) != 0x02 /* SoH request TLV */)
return NULL;
wpa_printf(MSG_DEBUG, "TNC: SoH Request TLV received");
return tncc_build_soh(2);
}
|
664058.c | /* ----------------------------------------------------------------------------
* Copyright (C) 2010-2014 ARM Limited. All rights reserved.
*
* $Date: 16/10/14 6:01p $Revision: V.1.4.5
*
* Project: CMSIS DSP Library
* Title: arm_mat_init_f32.c
*
* Description: Floating-point matrix initialization.
*
* Target Processor: Cortex-M4/Cortex-M3/Cortex-M0
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* -------------------------------------------------------------------------- */
#include "arm_math.h"
/**
* @ingroup groupMatrix
*/
/**
* @defgroup MatrixInit Matrix Initialization
*
* Initializes the underlying matrix data structure.
* The functions set the <code>numRows</code>,
* <code>numCols</code>, and <code>pData</code> fields
* of the matrix data structure.
*/
/**
* @addtogroup MatrixInit
* @{
*/
/**
* @brief Floating-point matrix initialization.
* @param[in,out] *S points to an instance of the floating-point matrix structure.
* @param[in] nRows number of rows in the matrix.
* @param[in] nColumns number of columns in the matrix.
* @param[in] *pData points to the matrix data array.
* @return none
*/
void arm_mat_init_f32(
arm_matrix_instance_f32 * S,
uint16_t nRows,
uint16_t nColumns,
float32_t * pData)
{
/* Assign Number of Rows */
S->numRows = nRows;
/* Assign Number of Columns */
S->numCols = nColumns;
/* Assign Data pointer */
S->pData = pData;
}
/**
* @} end of MatrixInit group
*/
|
685696.c | /*
* wifi_events.c
* Author: pvvx
*/
#include "user_config.h"
#include "bios/ets.h"
#include "sdk/add_func.h"
#include "sdk/libmain.h"
#include "ets_sys.h"
#include "os_type.h"
#include "osapi.h"
#include "user_interface.h"
#include "wifi.h"
#include "wifi_events.h"
#include "flash_eep.h"
#include "tcp2uart.h"
#include "web_srv.h"
#ifdef USE_SNTP
#include "sntp.h"
#include "power_meter.h"
#endif
#ifdef USE_CAPTDNS
#include "captdns.h"
#endif
#ifdef USE_NETBIOS
#include "netbios.h"
#endif
#ifdef USE_MODBUS
#include "modbustcp.h"
#endif
void iot_cloud_send(uint8 fwork) ICACHE_FLASH_ATTR;
struct s_probe_requests buf_probe_requests[MAX_COUNT_BUF_PROBEREQS] DATA_IRAM_ATTR;
uint32 probe_requests_count DATA_IRAM_ATTR;
#if DEBUGSOO > 2
#define PRINT_EVENT_REASON_ENABLE
#endif
#ifdef PRINT_EVENT_REASON_ENABLE
static const uint8 txt_reason_undef[] ICACHE_RODATA_ATTR = "Unknown"; // = 0,
static const uint8 txt_reason_unspecified[] ICACHE_RODATA_ATTR = "Unspecified"; // = 1,
static const uint8 txt_reason_auth_expire[] ICACHE_RODATA_ATTR = "Auth_expire"; // = 2,
static const uint8 txt_reason_auth_leave[] ICACHE_RODATA_ATTR = "Auth_leave"; // = 3,
static const uint8 txt_reason_assoc_expire[] ICACHE_RODATA_ATTR = "Assoc_expire"; // = 4,
static const uint8 txt_reason_assoc_toomany[] ICACHE_RODATA_ATTR = "Assoc_toomany"; // = 5,
static const uint8 txt_reason_not_authed[] ICACHE_RODATA_ATTR = "Not_authed"; // = 6,
static const uint8 txt_reason_not_assoced[] ICACHE_RODATA_ATTR = "Not_assoced"; // = 7,
static const uint8 txt_reason_assoc_leave[] ICACHE_RODATA_ATTR = "Assoc_leave"; // = 8,
static const uint8 txt_reason_assoc_not_authed[] ICACHE_RODATA_ATTR = "Assoc_not_authed"; // = 9,
static const uint8 txt_reason_disassoc_pwrcap_bad[] ICACHE_RODATA_ATTR = "Disassoc_pwrcap_bad"; // = 10, /* 11h */
static const uint8 txt_reason_disassoc_supchan_bad[] ICACHE_RODATA_ATTR = "Disassoc_supchan_bad"; // = 11, /* 11h */
static const uint8 txt_reason_ie_invalid[] ICACHE_RODATA_ATTR = "Ie_invalid"; // = 13, /* 11i */
static const uint8 txt_reason_mic_failure[] ICACHE_RODATA_ATTR = "Mic_failure"; // = 14, /* 11i */
static const uint8 txt_reason_4way_handshake_timeout[] ICACHE_RODATA_ATTR = "4way_handshake_timeout"; // = 15, /* 11i */
static const uint8 txt_reason_group_key_update_timeout[] ICACHE_RODATA_ATTR = "Group_key_update_timeout";// = 16, /* 11i */
static const uint8 txt_reason_ie_in_4way_differs[] ICACHE_RODATA_ATTR = "Ie_in_4way_differs"; // = 17, /* 11i */
static const uint8 txt_reason_group_cipher_invalid[] ICACHE_RODATA_ATTR = "Group_cipher_invalid"; // = 18, /* 11i */
static const uint8 txt_reason_pairwise_cipher_invalid[] ICACHE_RODATA_ATTR = "Pairwise_cipher_invalid"; // = 19, /* 11i */
static const uint8 txt_reason_akmp_invalid[] ICACHE_RODATA_ATTR = "Akmp_invalid"; // = 20, /* 11i */
static const uint8 txt_reason_unsupp_rsn_ie_version[] ICACHE_RODATA_ATTR = "Unsupp_rsn_ie_version"; // = 21, /* 11i */
static const uint8 txt_reason_invalid_rsn_ie_cap[] ICACHE_RODATA_ATTR = "Invalid_rsn_ie_cap"; // = 22, /* 11i */
static const uint8 txt_reason_802_1x_auth_failed[] ICACHE_RODATA_ATTR = "802_1x_auth_failed"; // = 23, /* 11i */
static const uint8 txt_reason_cipher_suite_rejected[] ICACHE_RODATA_ATTR = "Cipher_suite_rejected"; // = 24, /* 11i */
static const uint8 txt_reason_beacon_timeout[] ICACHE_RODATA_ATTR = "Beacon_timeout"; // = 200,
static const uint8 txt_reason_no_ap_found[] ICACHE_RODATA_ATTR = "No_ap_found"; // = 201,
static const uint8 txt_reason_auth_fail[] ICACHE_RODATA_ATTR = "Auth_fail"; // = 202,
static const uint8 txt_reason_assoc_fail[] ICACHE_RODATA_ATTR = "Assoc_fail"; // = 203,
static const uint8 txt_reason_handshake_timeout[] ICACHE_RODATA_ATTR = "Handshake_timeout"; // = 204
struct tab_event_reason {
const uint8 * txt;
};
const struct tab_event_reason tab_event_reason_1_24_200[] ICACHE_RODATA_ATTR = {
{txt_reason_unspecified},
{txt_reason_auth_expire},
{txt_reason_auth_leave},
{txt_reason_assoc_expire},
{txt_reason_assoc_toomany},
{txt_reason_not_authed},
{txt_reason_not_assoced},
{txt_reason_assoc_leave},
{txt_reason_assoc_not_authed},
{txt_reason_disassoc_pwrcap_bad},
{txt_reason_disassoc_supchan_bad},
{txt_reason_ie_invalid},
{txt_reason_mic_failure},
{txt_reason_4way_handshake_timeout},
{txt_reason_group_key_update_timeout},
{txt_reason_ie_in_4way_differs},
{txt_reason_group_cipher_invalid},
{txt_reason_pairwise_cipher_invalid},
{txt_reason_akmp_invalid},
{txt_reason_unsupp_rsn_ie_version},
{txt_reason_invalid_rsn_ie_cap},
{txt_reason_802_1x_auth_failed},
{txt_reason_cipher_suite_rejected},
// 200
{txt_reason_beacon_timeout},
{txt_reason_no_ap_found},
{txt_reason_auth_fail},
{txt_reason_assoc_fail},
{txt_reason_handshake_timeout}
};
/* static const * tab_event_reason_200_201 ICACHE_RODATA_ATTR = {
txt_reason_beacon_timeout,
txt_reason_no_ap_found }; */
void ICACHE_FLASH_ATTR print_event_reason(int reason)
{
const uint8 * txt_reason = txt_reason_unspecified;
if (reason >= 1 && reason <= 24) txt_reason = tab_event_reason_1_24_200[reason - 1].txt;
else if (reason >= 200 && reason <= 204) txt_reason = tab_event_reason_1_24_200[reason - 200 + 23].txt;
else txt_reason = txt_reason_undef;
os_printf_plus(txt_reason);
}
#endif // PRINT_EVENT_REASON_ENABLE
#define COUNT_RESCONN_ST 3 // кол-во непрерывных повторов попытки соединения ST модуля к внешней AP
int flg_open_all_service DATA_IRAM_ATTR; // default = false
int st_reconn_count DATA_IRAM_ATTR;
int st_reconn_flg DATA_IRAM_ATTR;
int flg_sleep DATA_IRAM_ATTR;
os_timer_t st_disconn_timer DATA_IRAM_ATTR;
/******************************************************************************
* FunctionName : station_reconnect_off
******************************************************************************/
void ICACHE_FLASH_ATTR station_reconnect_off(void)
{
st_reconn_count = 0;
st_reconn_flg = 0;
ets_timer_disarm(&st_disconn_timer);
}
/******************************************************************************
* FunctionName : station_connect_timer
* Таймер включения новой попытки соединения ST модуля к внешней AP
******************************************************************************/
void ICACHE_FLASH_ATTR station_connect_timer(void)
{
WiFi_up_from_sleep();
if(st_reconn_count != 0
&& (wifi_get_opmode() & STATION_MODE)
&& wifi_station_get_auto_connect() != 0) {
if(wifi_softap_get_station_num() == 0) { // Number count of stations which connected to ESP8266 soft-AP) {
#if DEBUGSOO > 1
os_printf("New connect ST...\n");
#endif
st_reconn_count = 0;
wifi_station_connect();
}
else {
#if DEBUGSOO > 1
os_printf("ST wait disconnect AP client...\n");
#endif
st_reconn_flg = 1;
}
}
}
/******************************************************************************
* FunctionName : add_next_probe_requests
* Запись нового probe_requests в буфер buf_probe_requests
******************************************************************************/
void ICACHE_FLASH_ATTR add_next_probe_requests(Event_SoftAPMode_ProbeReqRecved_t *pr)
{
uint32 i;
uint32 e = probe_requests_count;
if(e > MAX_COUNT_BUF_PROBEREQS) e = MAX_COUNT_BUF_PROBEREQS;
uint32 * ptrs = (uint32 *) (&pr->mac);
for(i = 0; i < e; i++) {
uint32 * ptrd = (uint32 *) (&buf_probe_requests[i]);
if(ptrs[0] == ptrd[0] && (ptrs[1]<<16) == (ptrd[1]<<16)) {
sint8 min = ptrd[1]>>16;
sint8 max = ptrd[1]>>24;
if(min > pr->rssi) min = pr->rssi;
else if(max < pr->rssi) max = pr->rssi;
ptrd[1] = (ptrd[1] & 0xFFFF) | ((min<<16) & 0xFF0000) | ((max<<24) & 0xFF000000);
return;
}
}
uint32 * ptrd = (uint32 *) (&buf_probe_requests[probe_requests_count & (MAX_COUNT_BUF_PROBEREQS-1)]);
ptrd[0] = ptrs[0];
ptrd[1] = (ptrs[1] & 0xFFFF) | ((pr->rssi << 16) & 0xFF0000) | ((pr->rssi << 24) & 0xFF000000);
if(++probe_requests_count == 0) probe_requests_count |= 0x80000000;
}
/******************************************************************************
* FunctionName : close_all_service
* Отключение интерфейсов для снижения потребления и т.д.
******************************************************************************/
void ICACHE_FLASH_ATTR close_all_service(void)
{
#if DEBUGSOO > 3
os_printf("Close all:\n");
#endif
if(flg_open_all_service) {
#ifdef USE_NETBIOS
netbios_off();
#endif
#ifdef USE_TCP2UART
tcp2uart_close();
#endif
#ifdef USE_MODBUS
mdb_tcp_close(); // mdb_tcp_init(0);
#endif
#ifdef USE_WEB
if(syscfg.web_port) webserver_close(syscfg.web_port); // webserver_init(0);
#endif
tcpsrv_close_all();
flg_open_all_service = false;
}
}
/******************************************************************************
* FunctionName : open_all_service
* if flg = 1 -> reopen
******************************************************************************/
void ICACHE_FLASH_ATTR open_all_service(int flg)
{
#if DEBUGSOO > 3
os_printf("Open all (%u,%u):\n", flg, flg_open_all_service);
#endif
#ifdef USE_TCP2UART
if(tcp2uart_servcfg == NULL) tcp2uart_start(syscfg.tcp2uart_port);
#endif
#ifdef USE_MODBUS
if(mdb_tcp_servcfg == NULL) mdb_tcp_start(syscfg.mdb_port);
#endif
#ifdef USE_SNTP
if(syscfg.cfg.b.sntp_ena && get_sntp_time() == 0) sntp_inits(UTC_OFFSET, cfg_glo.SNTP_update_delay_min, (char*)&cfg_glo.sntp_server);
#endif
if(flg == 0 || flg_open_all_service == false) {
#ifdef USE_WEB
if(syscfg.web_port) {
TCP_SERV_CFG *p = tcpsrv_server_port2pcfg(syscfg.web_port);
if(p != NULL) {
if(p->port != syscfg.web_port) {
tcpsrv_close(p);
p = NULL;
}
}
if(p == NULL) {
webserver_init(syscfg.web_port);
}
}
#endif
#ifdef USE_NETBIOS
if(syscfg.cfg.b.netbios_ena) netbios_init();
#endif
}
flg_open_all_service = true;
}
/******************************************************************************
* FunctionName : wifi_handle_event_cb
******************************************************************************/
void ICACHE_FLASH_ATTR wifi_handle_event_cb(System_Event_t *evt)
{
#if DEBUGSOO > 1
os_printf("WiFi event(%u): ", evt->event);
#endif
switch (evt->event) {
case EVENT_SOFTAPMODE_PROBEREQRECVED:
{
#if DEBUGSOO > 1
os_printf("Probe Request (MAC:" MACSTR ", RSSI:%d)\n",
MAC2STR(evt->event_info.ap_probereqrecved.mac),
evt->event_info.ap_probereqrecved.rssi);
#endif
add_next_probe_requests(&evt->event_info.ap_probereqrecved);
break;
}
case EVENT_STAMODE_CONNECTED:
{
#if DEBUGSOO > 1
os_printf("Connect to ssid %s, channel %d\n",
evt->event_info.connected.ssid,
evt->event_info.connected.channel);
#endif
station_reconnect_off();
break;
}
case EVENT_STAMODE_DISCONNECTED:
{
st_reconn_count++;
#ifdef PRINT_EVENT_REASON_ENABLE
os_printf("Disconnect from ssid %s, reason(%d): ", evt->event_info.disconnected.ssid, evt->event_info.disconnected.reason);
print_event_reason(evt->event_info.disconnected.reason);
os_printf(", count %d (rt=%d)\n", st_reconn_count, wificonfig.st.reconn_timeout);
#else
#if DEBUGSOO > 1
os_printf("Disconnect from ssid %s, reason %d, count %d\n",
evt->event_info.disconnected.ssid,
evt->event_info.disconnected.reason, st_reconn_count);
#endif
#endif // PRINT_EVENT_REASON_ENABLE
int opmode = wifi_get_opmode();
if((opmode & STATION_MODE) && ((wificonfig.st.reconn_timeout != 1 && st_reconn_count >= COUNT_RESCONN_ST)
|| evt->event_info.disconnected.reason == 4)) { // Assoc_expire
if(wifi_station_get_auto_connect() != 0) {
wifi_station_disconnect();
if(wificonfig.st.reconn_timeout > 1) {
#if DEBUGSOO > 1
os_printf("Set reconnect after %d sec\n", wificonfig.st.reconn_timeout);
#endif
ets_timer_disarm(&st_disconn_timer);
os_timer_setfn(&st_disconn_timer, (os_timer_func_t *)station_connect_timer, NULL);
ets_timer_arm_new(&st_disconn_timer, wificonfig.st.reconn_timeout * 1000, 0, 1);
}
#if DEBUGSOO > 1
else {
os_printf("Reconnect off\n");
}
#endif
if(opmode == STATION_MODE) {
if(wificonfig.b.sleep != LIGHT_SLEEP_T) WiFi_go_to_sleep(MODEM_SLEEP_T, 0xFFFFFFFF);
else WiFi_go_to_sleep(LIGHT_SLEEP_T, wificonfig.st.reconn_timeout * 1000000);
}
}
}
if(wifi_softap_get_station_num() == 0) { // Number count of stations which connected to ESP8266 soft-AP
close_all_service();
}
// iot_cloud
iot_cloud_send(0); // end
//
break;
}
case EVENT_STAMODE_AUTHMODE_CHANGE:
{
station_reconnect_off();
#if DEBUGSOO > 1
os_printf("New AuthMode: %d -> %d\n",
evt->event_info.auth_change.old_mode,
evt->event_info.auth_change.new_mode);
#endif
break;
}
case EVENT_STAMODE_GOT_IP:
{
station_reconnect_off();
#if DEBUGSOO > 1
os_printf("Station ip:" IPSTR ", mask:" IPSTR ", gw:" IPSTR "\n",
IP2STR(&evt->event_info.got_ip.ip),
IP2STR(&evt->event_info.got_ip.mask),
IP2STR(&evt->event_info.got_ip.gw));
#endif
open_all_service((wifi_softap_get_station_num() == 0)? 0: 1);
// iot_cloud
iot_cloud_send(1); // start
//
break;
}
case EVENT_SOFTAPMODE_STACONNECTED:
{
int i = wifi_softap_get_station_num(); // Number count of stations which connected to ESP8266 soft-AP
int cs = wifi_station_get_connect_status();
#if DEBUGSOO > 1
os_printf("Station[%u]: " MACSTR " join, AID = %d, %u\n",
i,
MAC2STR(evt->event_info.sta_connected.mac),
evt->event_info.sta_connected.aid, cs);
#endif
open_all_service((i == 1 && (!(cs == STATION_GOT_IP || cs == STATION_CONNECTING)))? 0 : 1);
#ifdef USE_CAPTDNS
if(syscfg.cfg.b.cdns_ena) {
captdns_init();
}
#endif
break;
}
case EVENT_SOFTAPMODE_STADISCONNECTED:
{
int i = wifi_softap_get_station_num(); // Number count of stations which connected to ESP8266 soft-AP
int cs = wifi_station_get_connect_status();
#if DEBUGSOO > 1
os_printf("Station[%u]: " MACSTR " leave, AID = %d, %u\n",
i,
MAC2STR(evt->event_info.sta_disconnected.mac),
evt->event_info.sta_disconnected.aid, cs);
#endif
if(i == 0) {
#ifdef USE_CAPTDNS
captdns_close();
#endif
if(!(cs == STATION_CONNECTING || cs == STATION_GOT_IP)) {
close_all_service();
if(st_reconn_flg != 0) {
if((wifi_get_opmode() & STATION_MODE) && wifi_station_get_auto_connect() != 0) {
station_reconnect_off();
#if DEBUGSOO > 1
os_printf("New connect ST...\n");
#endif
wifi_station_connect();
}
}
}
}
break;
}
#if DEBUGSOO > 1
case EVENT_STAMODE_DHCP_TIMEOUT:
os_printf("DHCP timeot\n");
break;
default:
os_printf("?\n");
break;
#endif
}
}
|
996134.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <dlfcn.h>
#include "wrappedlibs.h"
#include "debug.h"
#include "wrapper.h"
#include "bridge.h"
#include "librarian/library_private.h"
#include "x86emu.h"
#include "emu/x86emu_private.h"
#include "box86context.h"
#include "sdl2rwops.h"
typedef void* (*pFpi_t)(void*, int32_t);
typedef void* (*pFp_t)(void*);
typedef void* (*pFpip_t)(void*, int32_t, void*);
typedef int32_t (*iFppi_t)(void*, void*, int32_t);
typedef struct sdl2image_my_s {
pFp_t IMG_LoadBMP_RW;
pFp_t IMG_LoadCUR_RW;
pFp_t IMG_LoadGIF_RW;
pFp_t IMG_LoadICO_RW;
pFp_t IMG_LoadJPG_RW;
pFp_t IMG_LoadLBM_RW;
pFp_t IMG_LoadPCX_RW;
pFp_t IMG_LoadPNG_RW;
pFp_t IMG_LoadPNM_RW;
pFp_t IMG_LoadTGA_RW;
pFp_t IMG_LoadTIF_RW;
pFpip_t IMG_LoadTyped_RW;
pFp_t IMG_LoadWEBP_RW;
pFp_t IMG_LoadXCF_RW;
pFp_t IMG_LoadXPM_RW;
pFp_t IMG_LoadXV_RW;
pFpi_t IMG_Load_RW;
iFppi_t IMG_SavePNG_RW;
} sdl2image_my_t;
static void* getSDL2ImageMy(library_t* lib)
{
sdl2image_my_t* my = (sdl2image_my_t*)calloc(1, sizeof(sdl2image_my_t));
#define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
GO(IMG_LoadBMP_RW,pFp_t)
GO(IMG_LoadCUR_RW,pFp_t)
GO(IMG_LoadGIF_RW,pFp_t)
GO(IMG_LoadICO_RW,pFp_t)
GO(IMG_LoadJPG_RW,pFp_t)
GO(IMG_LoadLBM_RW,pFp_t)
GO(IMG_LoadPCX_RW,pFp_t)
GO(IMG_LoadPNG_RW,pFp_t)
GO(IMG_LoadPNM_RW,pFp_t)
GO(IMG_LoadTGA_RW,pFp_t)
GO(IMG_LoadTIF_RW,pFp_t)
GO(IMG_LoadTyped_RW,pFpip_t)
GO(IMG_LoadWEBP_RW,pFp_t)
GO(IMG_LoadXCF_RW,pFp_t)
GO(IMG_LoadXPM_RW,pFp_t)
GO(IMG_LoadXV_RW,pFp_t)
GO(IMG_Load_RW,pFpi_t)
GO(IMG_SavePNG_RW, iFppi_t)
#undef GO
return my;
}
#define GO(A) \
EXPORT void *my2_##A(x86emu_t* emu, void* a) \
{ \
sdl2image_my_t *my = (sdl2image_my_t *)emu->context->sdl2imagelib->priv.w.p2; \
SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a); \
void* r = my->A(rw); \
RWNativeEnd2(rw); \
return r; \
}
GO(IMG_LoadBMP_RW)
GO(IMG_LoadCUR_RW)
GO(IMG_LoadGIF_RW)
GO(IMG_LoadICO_RW)
GO(IMG_LoadJPG_RW)
GO(IMG_LoadLBM_RW)
GO(IMG_LoadPCX_RW)
GO(IMG_LoadPNG_RW)
GO(IMG_LoadPNM_RW)
GO(IMG_LoadTGA_RW)
GO(IMG_LoadTIF_RW)
GO(IMG_LoadWEBP_RW)
GO(IMG_LoadXCF_RW)
GO(IMG_LoadXPM_RW)
GO(IMG_LoadXV_RW)
#undef GO
EXPORT void *my2_IMG_LoadTyped_RW(x86emu_t* emu, void* a, int32_t b, void* c)
{
sdl2image_my_t *my = (sdl2image_my_t *)emu->context->sdl2imagelib->priv.w.p2;
SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
void* r = my->IMG_LoadTyped_RW(rw, b, c);
if(b==0)
RWNativeEnd2(rw);
return r;
}
EXPORT void *my2_IMG_Load_RW(x86emu_t* emu, void* a, int32_t b)
{
sdl2image_my_t *my = (sdl2image_my_t *)emu->context->sdl2imagelib->priv.w.p2;
SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
void* r = my->IMG_Load_RW(rw, b);
if(b==0)
RWNativeEnd2(rw);
return r;
}
EXPORT int32_t my2_IMG_SavePNG_RW(x86emu_t* emu, void* a, void* surf, int32_t compression)
{
sdl2image_my_t *my = (sdl2image_my_t *)emu->context->sdl2imagelib->priv.w.p2;
SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
int32_t r = my->IMG_SavePNG_RW(rw, surf, compression);
RWNativeEnd2(rw);
return r;
}
const char* sdl2imageName = "libSDL2_image-2.0.so.0";
#define LIBNAME sdl2image
#define CUSTOM_INIT \
box86->sdl2imagelib = lib; \
lib->priv.w.p2 = getSDL2ImageMy(lib); \
lib->altmy = strdup("my2_");
#define CUSTOM_FINI \
free(lib->priv.w.p2); \
((box86context_t*)(lib->context))->sdl2imagelib = NULL;
#include "wrappedlib_init.h"
|
939976.c | /*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*/
/** \file
* \ingroup edobj
*/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "MEM_guardedalloc.h"
#include "DNA_anim_types.h"
#include "DNA_armature_types.h"
#include "DNA_curve_types.h"
#include "DNA_dynamicpaint_types.h"
#include "DNA_fluid_types.h"
#include "DNA_key_types.h"
#include "DNA_lattice_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_force_types.h"
#include "DNA_scene_types.h"
#include "DNA_space_types.h"
#include "BLI_bitmap.h"
#include "BLI_listbase.h"
#include "BLI_math.h"
#include "BLI_path_util.h"
#include "BLI_string.h"
#include "BLI_string_utf8.h"
#include "BLI_utildefines.h"
#include "BKE_DerivedMesh.h"
#include "BKE_animsys.h"
#include "BKE_armature.h"
#include "BKE_context.h"
#include "BKE_curve.h"
#include "BKE_displist.h"
#include "BKE_editmesh.h"
#include "BKE_effect.h"
#include "BKE_global.h"
#include "BKE_gpencil_modifier.h"
#include "BKE_hair.h"
#include "BKE_key.h"
#include "BKE_lattice.h"
#include "BKE_lib_id.h"
#include "BKE_main.h"
#include "BKE_mesh.h"
#include "BKE_mesh_mapping.h"
#include "BKE_mesh_runtime.h"
#include "BKE_modifier.h"
#include "BKE_multires.h"
#include "BKE_object.h"
#include "BKE_object_deform.h"
#include "BKE_ocean.h"
#include "BKE_paint.h"
#include "BKE_particle.h"
#include "BKE_pointcloud.h"
#include "BKE_report.h"
#include "BKE_scene.h"
#include "BKE_softbody.h"
#include "BKE_volume.h"
#include "DEG_depsgraph.h"
#include "DEG_depsgraph_build.h"
#include "DEG_depsgraph_query.h"
#include "RNA_access.h"
#include "RNA_define.h"
#include "RNA_enum_types.h"
#include "ED_armature.h"
#include "ED_mesh.h"
#include "ED_object.h"
#include "ED_screen.h"
#include "ED_sculpt.h"
#include "MOD_nodes.h"
#include "UI_interface.h"
#include "WM_api.h"
#include "WM_types.h"
#include "object_intern.h"
static void modifier_skin_customdata_delete(struct Object *ob);
/* ------------------------------------------------------------------- */
/** \name Public Api
* \{ */
static void object_force_modifier_update_for_bind(Depsgraph *depsgraph, Object *ob)
{
Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
BKE_object_eval_reset(ob_eval);
if (ob->type == OB_MESH) {
Mesh *me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
BKE_mesh_eval_delete(me_eval);
}
else if (ob->type == OB_LATTICE) {
BKE_lattice_modifiers_calc(depsgraph, scene_eval, ob_eval);
}
else if (ob->type == OB_MBALL) {
BKE_displist_make_mball(depsgraph, scene_eval, ob_eval);
}
else if (ELEM(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
BKE_displist_make_curveTypes(depsgraph, scene_eval, ob_eval, false, false);
}
else if (ob->type == OB_GPENCIL) {
BKE_gpencil_modifiers_calc(depsgraph, scene_eval, ob_eval);
}
else if (ob->type == OB_HAIR) {
BKE_hair_data_update(depsgraph, scene_eval, ob);
}
else if (ob->type == OB_POINTCLOUD) {
BKE_pointcloud_data_update(depsgraph, scene_eval, ob);
}
else if (ob->type == OB_VOLUME) {
BKE_volume_data_update(depsgraph, scene_eval, ob);
}
}
static void object_force_modifier_bind_simple_options(Depsgraph *depsgraph,
Object *object,
ModifierData *md)
{
ModifierData *md_eval = (ModifierData *)BKE_modifier_get_evaluated(depsgraph, object, md);
const int mode = md_eval->mode;
md_eval->mode |= eModifierMode_Realtime;
object_force_modifier_update_for_bind(depsgraph, object);
md_eval->mode = mode;
}
/**
* Add a modifier to given object, including relevant extra processing needed by some physics types
* (particles, simulations...).
*
* \param scene: is only used to set current frame in some cases, and may be NULL.
*/
ModifierData *ED_object_modifier_add(
ReportList *reports, Main *bmain, Scene *scene, Object *ob, const char *name, int type)
{
ModifierData *md = NULL, *new_md = NULL;
const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
/* Check compatibility of modifier [T25291, T50373]. */
if (!BKE_object_support_modifier_type_check(ob, type)) {
BKE_reportf(reports, RPT_WARNING, "Modifiers cannot be added to object '%s'", ob->id.name + 2);
return NULL;
}
if (mti->flags & eModifierTypeFlag_Single) {
if (BKE_modifiers_findby_type(ob, type)) {
BKE_report(reports, RPT_WARNING, "Only one modifier of this type is allowed");
return NULL;
}
}
if (type == eModifierType_ParticleSystem) {
/* don't need to worry about the new modifier's name, since that is set to the number
* of particle systems which shouldn't have too many duplicates
*/
new_md = object_add_particle_system(bmain, scene, ob, name);
}
else {
/* get new modifier data to add */
new_md = BKE_modifier_new(type);
if (mti->flags & eModifierTypeFlag_RequiresOriginalData) {
md = ob->modifiers.first;
while (md && BKE_modifier_get_info(md->type)->type == eModifierTypeType_OnlyDeform) {
md = md->next;
}
BLI_insertlinkbefore(&ob->modifiers, md, new_md);
}
else {
BLI_addtail(&ob->modifiers, new_md);
}
if (name) {
BLI_strncpy_utf8(new_md->name, name, sizeof(new_md->name));
}
/* make sure modifier data has unique name */
BKE_modifier_unique_name(&ob->modifiers, new_md);
/* special cases */
if (type == eModifierType_Softbody) {
if (!ob->soft) {
ob->soft = sbNew(scene);
ob->softflag |= OB_SB_GOAL | OB_SB_EDGES;
}
}
else if (type == eModifierType_Collision) {
if (!ob->pd) {
ob->pd = BKE_partdeflect_new(0);
}
ob->pd->deflect = 1;
}
else if (type == eModifierType_Surface) {
/* pass */
}
else if (type == eModifierType_Multires) {
/* set totlvl from existing MDISPS layer if object already had it */
multiresModifier_set_levels_from_disps((MultiresModifierData *)new_md, ob);
if (ob->mode & OB_MODE_SCULPT) {
/* ensure that grid paint mask layer is created */
BKE_sculpt_mask_layers_ensure(ob, (MultiresModifierData *)new_md);
}
}
else if (type == eModifierType_Skin) {
/* ensure skin-node customdata exists */
BKE_mesh_ensure_skin_customdata(ob->data);
}
else if (type == eModifierType_Nodes) {
MOD_nodes_init(bmain, (NodesModifierData *)new_md);
}
}
BKE_object_modifier_set_active(ob, new_md);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
DEG_relations_tag_update(bmain);
return new_md;
}
/* Return true if the object has a modifier of type 'type' other than
* the modifier pointed to be 'exclude', otherwise returns false. */
static bool object_has_modifier(const Object *ob, const ModifierData *exclude, ModifierType type)
{
LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
if ((md != exclude) && (md->type == type)) {
return true;
}
}
return false;
}
/* If the object data of 'orig_ob' has other users, run 'callback' on
* each of them.
*
* If include_orig is true, the callback will run on 'orig_ob' too.
*
* If the callback ever returns true, iteration will stop and the
* function value will be true. Otherwise the function returns false.
*/
bool ED_object_iter_other(Main *bmain,
Object *orig_ob,
const bool include_orig,
bool (*callback)(Object *ob, void *callback_data),
void *callback_data)
{
ID *ob_data_id = orig_ob->data;
int users = ob_data_id->us;
if (ob_data_id->flag & LIB_FAKEUSER) {
users--;
}
/* First check that the object's data has multiple users */
if (users > 1) {
Object *ob;
int totfound = include_orig ? 0 : 1;
for (ob = bmain->objects.first; ob && totfound < users; ob = ob->id.next) {
if (((ob != orig_ob) || include_orig) && (ob->data == orig_ob->data)) {
if (callback(ob, callback_data)) {
return true;
}
totfound++;
}
}
}
else if (include_orig) {
return callback(orig_ob, callback_data);
}
return false;
}
static bool object_has_modifier_cb(Object *ob, void *data)
{
ModifierType type = *((ModifierType *)data);
return object_has_modifier(ob, NULL, type);
}
/* Use with ED_object_iter_other(). Sets the total number of levels
* for any multires modifiers on the object to the int pointed to by
* callback_data. */
bool ED_object_multires_update_totlevels_cb(Object *ob, void *totlevel_v)
{
int totlevel = *((char *)totlevel_v);
LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
if (md->type == eModifierType_Multires) {
multires_set_tot_level(ob, (MultiresModifierData *)md, totlevel);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
}
return false;
}
/* Return true if no modifier of type 'type' other than 'exclude' */
static bool object_modifier_safe_to_delete(Main *bmain,
Object *ob,
ModifierData *exclude,
ModifierType type)
{
return (!object_has_modifier(ob, exclude, type) &&
!ED_object_iter_other(bmain, ob, false, object_has_modifier_cb, &type));
}
static bool object_modifier_remove(
Main *bmain, Scene *scene, Object *ob, ModifierData *md, bool *r_sort_depsgraph)
{
/* It seems on rapid delete it is possible to
* get called twice on same modifier, so make
* sure it is in list. */
if (BLI_findindex(&ob->modifiers, md) == -1) {
return false;
}
/* special cases */
if (md->type == eModifierType_ParticleSystem) {
object_remove_particle_system(bmain, scene, ob);
return true;
}
if (md->type == eModifierType_Softbody) {
if (ob->soft) {
sbFree(ob);
ob->softflag = 0; /* TODO(Sybren): this should probably be moved into sbFree() */
}
}
else if (md->type == eModifierType_Collision) {
if (ob->pd) {
ob->pd->deflect = 0;
}
*r_sort_depsgraph = true;
}
else if (md->type == eModifierType_Surface) {
*r_sort_depsgraph = true;
}
else if (md->type == eModifierType_Multires) {
/* Delete MDisps layer if not used by another multires modifier */
if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_Multires)) {
multires_customdata_delete(ob->data);
}
}
else if (md->type == eModifierType_Skin) {
/* Delete MVertSkin layer if not used by another skin modifier */
if (object_modifier_safe_to_delete(bmain, ob, md, eModifierType_Skin)) {
modifier_skin_customdata_delete(ob);
}
}
if (ELEM(md->type, eModifierType_Softbody, eModifierType_Cloth) &&
BLI_listbase_is_empty(&ob->particlesystem)) {
ob->mode &= ~OB_MODE_PARTICLE_EDIT;
}
BKE_modifier_remove_from_list(ob, md);
BKE_modifier_free(md);
BKE_object_free_derived_caches(ob);
return true;
}
bool ED_object_modifier_remove(
ReportList *reports, Main *bmain, Scene *scene, Object *ob, ModifierData *md)
{
bool sort_depsgraph = false;
bool ok = object_modifier_remove(bmain, scene, ob, md, &sort_depsgraph);
if (!ok) {
BKE_reportf(reports, RPT_ERROR, "Modifier '%s' not in object '%s'", md->name, ob->id.name);
return false;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
DEG_relations_tag_update(bmain);
return true;
}
void ED_object_modifier_clear(Main *bmain, Scene *scene, Object *ob)
{
ModifierData *md = ob->modifiers.first;
bool sort_depsgraph = false;
if (!md) {
return;
}
while (md) {
ModifierData *next_md = md->next;
object_modifier_remove(bmain, scene, ob, md, &sort_depsgraph);
md = next_md;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
DEG_relations_tag_update(bmain);
}
bool ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md)
{
if (md->prev) {
const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
if (mti->type != eModifierTypeType_OnlyDeform) {
const ModifierTypeInfo *nmti = BKE_modifier_get_info(md->prev->type);
if (nmti->flags & eModifierTypeFlag_RequiresOriginalData) {
BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data");
return false;
}
}
BLI_listbase_swaplinks(&ob->modifiers, md, md->prev);
}
else {
BKE_report(reports, RPT_WARNING, "Cannot move modifier beyond the start of the list");
return false;
}
return true;
}
bool ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md)
{
if (md->next) {
const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
if (mti->flags & eModifierTypeFlag_RequiresOriginalData) {
const ModifierTypeInfo *nmti = BKE_modifier_get_info(md->next->type);
if (nmti->type != eModifierTypeType_OnlyDeform) {
BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier");
return false;
}
}
BLI_listbase_swaplinks(&ob->modifiers, md, md->next);
}
else {
BKE_report(reports, RPT_WARNING, "Cannot move modifier beyond the end of the list");
return false;
}
return true;
}
bool ED_object_modifier_move_to_index(ReportList *reports,
Object *ob,
ModifierData *md,
const int index)
{
BLI_assert(md != NULL);
BLI_assert(index >= 0);
if (index >= BLI_listbase_count(&ob->modifiers)) {
BKE_report(reports, RPT_WARNING, "Cannot move modifier beyond the end of the stack");
return false;
}
int md_index = BLI_findindex(&ob->modifiers, md);
BLI_assert(md_index != -1);
if (md_index < index) {
/* Move modifier down in list. */
for (; md_index < index; md_index++) {
if (!ED_object_modifier_move_down(reports, ob, md)) {
break;
}
}
}
else {
/* Move modifier up in list. */
for (; md_index > index; md_index--) {
if (!ED_object_modifier_move_up(reports, ob, md)) {
break;
}
}
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
return true;
}
void ED_object_modifier_link(bContext *C, Object *ob_dst, Object *ob_src)
{
BKE_object_link_modifiers(ob_dst, ob_src);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob_dst);
DEG_id_tag_update(&ob_dst->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
Main *bmain = CTX_data_main(C);
DEG_relations_tag_update(bmain);
}
void ED_object_modifier_copy_to_object(bContext *C,
Object *ob_dst,
Object *ob_src,
ModifierData *md)
{
BKE_object_copy_modifier(CTX_data_main(C), CTX_data_scene(C), ob_dst, ob_src, md);
WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob_dst);
DEG_id_tag_update(&ob_dst->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
Main *bmain = CTX_data_main(C);
DEG_relations_tag_update(bmain);
}
bool ED_object_modifier_convert(ReportList *UNUSED(reports),
Main *bmain,
Depsgraph *depsgraph,
ViewLayer *view_layer,
Object *ob,
ModifierData *md)
{
int cvert = 0;
if (md->type != eModifierType_ParticleSystem) {
return false;
}
if (ob && ob->mode & OB_MODE_PARTICLE_EDIT) {
return false;
}
ParticleSystem *psys_orig = ((ParticleSystemModifierData *)md)->psys;
ParticleSettings *part = psys_orig->part;
if (part->ren_as != PART_DRAW_PATH) {
return false;
}
ParticleSystem *psys_eval = psys_eval_get(depsgraph, ob, psys_orig);
if (psys_eval->pathcache == NULL) {
return false;
}
int totpart = psys_eval->totcached;
int totchild = psys_eval->totchildcache;
if (totchild && (part->draw & PART_DRAW_PARENT) == 0) {
totpart = 0;
}
/* count */
int totvert = 0, totedge = 0;
ParticleCacheKey **cache = psys_eval->pathcache;
for (int a = 0; a < totpart; a++) {
ParticleCacheKey *key = cache[a];
if (key->segments > 0) {
totvert += key->segments + 1;
totedge += key->segments;
}
}
cache = psys_eval->childcache;
for (int a = 0; a < totchild; a++) {
ParticleCacheKey *key = cache[a];
if (key->segments > 0) {
totvert += key->segments + 1;
totedge += key->segments;
}
}
if (totvert == 0) {
return false;
}
/* add new mesh */
Object *obn = BKE_object_add(bmain, view_layer, OB_MESH, NULL);
Mesh *me = obn->data;
me->totvert = totvert;
me->totedge = totedge;
me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, 0);
MVert *mvert = me->mvert;
MEdge *medge = me->medge;
/* copy coordinates */
cache = psys_eval->pathcache;
for (int a = 0; a < totpart; a++) {
ParticleCacheKey *key = cache[a];
int kmax = key->segments;
for (int k = 0; k <= kmax; k++, key++, cvert++, mvert++) {
copy_v3_v3(mvert->co, key->co);
if (k) {
medge->v1 = cvert - 1;
medge->v2 = cvert;
medge->flag = ME_EDGEDRAW | ME_EDGERENDER | ME_LOOSEEDGE;
medge++;
}
else {
/* cheap trick to select the roots */
mvert->flag |= SELECT;
}
}
}
cache = psys_eval->childcache;
for (int a = 0; a < totchild; a++) {
ParticleCacheKey *key = cache[a];
int kmax = key->segments;
for (int k = 0; k <= kmax; k++, key++, cvert++, mvert++) {
copy_v3_v3(mvert->co, key->co);
if (k) {
medge->v1 = cvert - 1;
medge->v2 = cvert;
medge->flag = ME_EDGEDRAW | ME_EDGERENDER | ME_LOOSEEDGE;
medge++;
}
else {
/* cheap trick to select the roots */
mvert->flag |= SELECT;
}
}
}
DEG_relations_tag_update(bmain);
return true;
}
/* Gets mesh for the modifier which corresponds to an evaluated state. */
static Mesh *modifier_apply_create_mesh_for_modifier(Depsgraph *depsgraph,
Object *object,
ModifierData *md_eval,
bool build_shapekey_layers)
{
Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
Mesh *mesh_applied = BKE_mesh_create_derived_for_modifier(
depsgraph, scene_eval, object_eval, md_eval, build_shapekey_layers);
return mesh_applied;
}
static bool modifier_apply_shape(Main *bmain,
ReportList *reports,
Depsgraph *depsgraph,
Scene *scene,
Object *ob,
ModifierData *md_eval)
{
const ModifierTypeInfo *mti = BKE_modifier_get_info(md_eval->type);
if (mti->isDisabled && mti->isDisabled(scene, md_eval, 0)) {
BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
return false;
}
/* We could investigate using the #CD_ORIGINDEX layer
* to support other kinds of modifiers besides deforming modifiers.
* as this is done in many other places, see: #BKE_mesh_foreach_mapped_vert_coords_get.
*
* This isn't high priority in practice since most modifiers users
* want to apply as a shape are deforming modifiers.
*
* If a compelling use-case comes up where we want to support other kinds of modifiers
* we can look into supporting them. */
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
Key *key = me->key;
if (!BKE_modifier_is_same_topology(md_eval) || mti->type == eModifierTypeType_NonGeometrical) {
BKE_report(reports, RPT_ERROR, "Only deforming modifiers can be applied to shapes");
return false;
}
Mesh *mesh_applied = modifier_apply_create_mesh_for_modifier(depsgraph, ob, md_eval, false);
if (!mesh_applied) {
BKE_report(reports, RPT_ERROR, "Modifier is disabled or returned error, skipping apply");
return false;
}
if (key == NULL) {
key = me->key = BKE_key_add(bmain, (ID *)me);
key->type = KEY_RELATIVE;
/* if that was the first key block added, then it was the basis.
* Initialize it with the mesh, and add another for the modifier */
KeyBlock *kb = BKE_keyblock_add(key, NULL);
BKE_keyblock_convert_from_mesh(me, key, kb);
}
KeyBlock *kb = BKE_keyblock_add(key, md_eval->name);
BKE_mesh_nomain_to_meshkey(mesh_applied, me, kb);
BKE_id_free(NULL, mesh_applied);
}
else {
/* TODO: implement for hair, point-clouds and volumes. */
BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
return false;
}
return true;
}
static bool modifier_apply_obdata(
ReportList *reports, Depsgraph *depsgraph, Scene *scene, Object *ob, ModifierData *md_eval)
{
const ModifierTypeInfo *mti = BKE_modifier_get_info(md_eval->type);
if (mti->isDisabled && mti->isDisabled(scene, md_eval, 0)) {
BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
return false;
}
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
MultiresModifierData *mmd = find_multires_modifier_before(scene, md_eval);
if (me->key && mti->type != eModifierTypeType_NonGeometrical) {
BKE_report(reports, RPT_ERROR, "Modifier cannot be applied to a mesh with shape keys");
return false;
}
/* Multires: ensure that recent sculpting is applied */
if (md_eval->type == eModifierType_Multires) {
multires_force_sculpt_rebuild(ob);
}
if (mmd && mmd->totlvl && mti->type == eModifierTypeType_OnlyDeform) {
if (!multiresModifier_reshapeFromDeformModifier(depsgraph, ob, mmd, md_eval)) {
BKE_report(reports, RPT_ERROR, "Multires modifier returned error, skipping apply");
return false;
}
}
else {
Mesh *mesh_applied = modifier_apply_create_mesh_for_modifier(depsgraph, ob, md_eval, true);
if (!mesh_applied) {
BKE_report(reports, RPT_ERROR, "Modifier returned error, skipping apply");
return false;
}
BKE_mesh_nomain_to_mesh(mesh_applied, me, ob, &CD_MASK_MESH, true);
if (md_eval->type == eModifierType_Multires) {
multires_customdata_delete(me);
}
}
}
else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
Curve *curve = ob->data;
Curve *curve_eval = (Curve *)object_eval->data;
ModifierEvalContext mectx = {depsgraph, object_eval, 0};
if (ELEM(mti->type, eModifierTypeType_Constructive, eModifierTypeType_Nonconstructive)) {
BKE_report(
reports, RPT_ERROR, "Transform curve to mesh in order to apply constructive modifiers");
return false;
}
BKE_report(reports,
RPT_INFO,
"Applied modifier only changed CV points, not tessellated/bevel vertices");
int numVerts;
float(*vertexCos)[3] = BKE_curve_nurbs_vert_coords_alloc(&curve_eval->nurb, &numVerts);
mti->deformVerts(md_eval, &mectx, NULL, vertexCos, numVerts);
BKE_curve_nurbs_vert_coords_apply(&curve->nurb, vertexCos, false);
MEM_freeN(vertexCos);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
else if (ob->type == OB_LATTICE) {
Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
Lattice *lattice = ob->data;
ModifierEvalContext mectx = {depsgraph, object_eval, 0};
if (ELEM(mti->type, eModifierTypeType_Constructive, eModifierTypeType_Nonconstructive)) {
BKE_report(reports, RPT_ERROR, "Constructive modifiers cannot be applied");
return false;
}
int numVerts;
float(*vertexCos)[3] = BKE_lattice_vert_coords_alloc(lattice, &numVerts);
mti->deformVerts(md_eval, &mectx, NULL, vertexCos, numVerts);
BKE_lattice_vert_coords_apply(lattice, vertexCos);
MEM_freeN(vertexCos);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
else {
/* TODO: implement for hair, point-clouds and volumes. */
BKE_report(reports, RPT_ERROR, "Cannot apply modifier for this object type");
return false;
}
/* lattice modifier can be applied to particle system too */
if (ob->particlesystem.first) {
LISTBASE_FOREACH (ParticleSystem *, psys, &ob->particlesystem) {
if (psys->part->type != PART_HAIR) {
continue;
}
psys_apply_hair_lattice(depsgraph, scene, ob, psys);
}
}
return true;
}
bool ED_object_modifier_apply(Main *bmain,
ReportList *reports,
Depsgraph *depsgraph,
Scene *scene,
Object *ob,
ModifierData *md,
int mode,
bool keep_modifier)
{
if (BKE_object_is_in_editmode(ob)) {
BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied in edit mode");
return false;
}
if (mode != MODIFIER_APPLY_SHAPE && ID_REAL_USERS(ob->data) > 1) {
BKE_report(reports, RPT_ERROR, "Modifiers cannot be applied to multi-user data");
return false;
}
if ((ob->mode & OB_MODE_SCULPT) && (find_multires_modifier_before(scene, md)) &&
(BKE_modifier_is_same_topology(md) == false)) {
BKE_report(reports,
RPT_ERROR,
"Constructive modifier cannot be applied to multi-res data in sculpt mode");
return false;
}
if (md != ob->modifiers.first) {
BKE_report(reports, RPT_INFO, "Applied modifier was not first, result may not be as expected");
}
/* Get evaluated modifier, so object links pointer to evaluated data,
* but still use original object it is applied to the original mesh. */
Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
ModifierData *md_eval = (ob_eval) ? BKE_modifiers_findby_name(ob_eval, md->name) : md;
/* allow apply of a not-realtime modifier, by first re-enabling realtime. */
int prev_mode = md_eval->mode;
md_eval->mode |= eModifierMode_Realtime;
if (mode == MODIFIER_APPLY_SHAPE) {
if (!modifier_apply_shape(bmain, reports, depsgraph, scene, ob, md_eval)) {
md_eval->mode = prev_mode;
return false;
}
}
else {
if (!modifier_apply_obdata(reports, depsgraph, scene, ob, md_eval)) {
md_eval->mode = prev_mode;
return false;
}
}
md_eval->mode = prev_mode;
if (!keep_modifier) {
BKE_modifier_remove_from_list(ob, md);
BKE_modifier_free(md);
}
BKE_object_free_derived_caches(ob);
return true;
}
bool ED_object_modifier_copy(
ReportList *UNUSED(reports), Main *bmain, Scene *scene, Object *ob, ModifierData *md)
{
if (md->type == eModifierType_ParticleSystem) {
ModifierData *nmd = object_copy_particle_system(
bmain, scene, ob, ((ParticleSystemModifierData *)md)->psys);
BLI_remlink(&ob->modifiers, nmd);
BLI_insertlinkafter(&ob->modifiers, md, nmd);
BKE_object_modifier_set_active(ob, nmd);
return true;
}
ModifierData *nmd = BKE_modifier_new(md->type);
BKE_modifier_copydata(md, nmd);
BLI_insertlinkafter(&ob->modifiers, md, nmd);
BKE_modifier_unique_name(&ob->modifiers, nmd);
BKE_object_modifier_set_active(ob, nmd);
nmd->flag |= eModifierFlag_OverrideLibrary_Local;
return true;
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Add Modifier Operator
* \{ */
static int modifier_add_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
Object *ob = ED_object_active_context(C);
int type = RNA_enum_get(op->ptr, "type");
if (!ED_object_modifier_add(op->reports, bmain, scene, ob, NULL, type)) {
return OPERATOR_CANCELLED;
}
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static const EnumPropertyItem *modifier_add_itemf(bContext *C,
PointerRNA *UNUSED(ptr),
PropertyRNA *UNUSED(prop),
bool *r_free)
{
Object *ob = ED_object_active_context(C);
if (!ob) {
return rna_enum_object_modifier_type_items;
}
EnumPropertyItem *items = NULL;
int totitem = 0;
const EnumPropertyItem *group_item = NULL;
for (int a = 0; rna_enum_object_modifier_type_items[a].identifier; a++) {
const EnumPropertyItem *md_item = &rna_enum_object_modifier_type_items[a];
if (md_item->identifier[0]) {
const ModifierTypeInfo *mti = BKE_modifier_get_info(md_item->value);
if (mti->flags & eModifierTypeFlag_NoUserAdd) {
continue;
}
if (!BKE_object_support_modifier_type_check(ob, md_item->value)) {
continue;
}
}
else {
group_item = md_item;
continue;
}
if (group_item) {
RNA_enum_item_add(&items, &totitem, group_item);
group_item = NULL;
}
RNA_enum_item_add(&items, &totitem, md_item);
}
RNA_enum_item_end(&items, &totitem);
*r_free = true;
return items;
}
void OBJECT_OT_modifier_add(wmOperatorType *ot)
{
PropertyRNA *prop;
/* identifiers */
ot->name = "Add Modifier";
ot->description = "Add a procedural operation/effect to the active object";
ot->idname = "OBJECT_OT_modifier_add";
/* api callbacks */
ot->invoke = WM_menu_invoke;
ot->exec = modifier_add_exec;
ot->poll = ED_operator_object_active_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
/* properties */
prop = RNA_def_enum(
ot->srna, "type", rna_enum_object_modifier_type_items, eModifierType_Subsurf, "Type", "");
RNA_def_enum_funcs(prop, modifier_add_itemf);
ot->prop = prop;
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Generic Poll Function and Properties
*
* Using modifier names and data context.
* \{ */
bool edit_modifier_poll_generic(bContext *C,
StructRNA *rna_type,
int obtype_flag,
const bool is_editmode_allowed,
const bool is_liboverride_allowed)
{
PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", rna_type);
Object *ob = (ptr.owner_id) ? (Object *)ptr.owner_id : ED_object_active_context(C);
ModifierData *mod = ptr.data; /* May be NULL. */
if (!ob || ID_IS_LINKED(ob)) {
return false;
}
if (obtype_flag && ((1 << ob->type) & obtype_flag) == 0) {
return false;
}
if (ptr.owner_id && ID_IS_LINKED(ptr.owner_id)) {
return false;
}
if (!is_liboverride_allowed && BKE_modifier_is_nonlocal_in_liboverride(ob, mod)) {
CTX_wm_operator_poll_msg_set(
C, "Cannot edit modifiers coming from linked data in a library override");
return false;
}
if (!is_editmode_allowed && CTX_data_edit_object(C) != NULL) {
CTX_wm_operator_poll_msg_set(C, "This modifier operation is not allowed from Edit mode");
return false;
}
return true;
}
static bool edit_modifier_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_Modifier, 0, true, false);
}
/* Used by operators performing actions allowed also on modifiers from the overridden linked object
* (not only from added 'local' ones). */
static bool edit_modifier_liboverride_allowed_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_Modifier, 0, true, true);
}
void edit_modifier_properties(wmOperatorType *ot)
{
PropertyRNA *prop = RNA_def_string(
ot->srna, "modifier", NULL, MAX_NAME, "Modifier", "Name of the modifier to edit");
RNA_def_property_flag(prop, PROP_HIDDEN);
}
static void edit_modifier_report_property(wmOperatorType *ot)
{
PropertyRNA *prop = RNA_def_boolean(
ot->srna, "report", false, "Report", "Create a notification after the operation");
RNA_def_property_flag(prop, PROP_HIDDEN);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Generic Invoke Functions
*
* Using modifier names and data context.
* \{ */
bool edit_modifier_invoke_properties(bContext *C, wmOperator *op)
{
if (RNA_struct_property_is_set(op->ptr, "modifier")) {
return true;
}
PointerRNA ctx_ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
if (ctx_ptr.data != NULL) {
ModifierData *md = ctx_ptr.data;
RNA_string_set(op->ptr, "modifier", md->name);
return true;
}
return false;
}
ModifierData *edit_modifier_property_get(wmOperator *op, Object *ob, int type)
{
char modifier_name[MAX_NAME];
RNA_string_get(op->ptr, "modifier", modifier_name);
ModifierData *md = BKE_modifiers_findby_name(ob, modifier_name);
if (md && type != 0 && md->type != type) {
md = NULL;
}
return md;
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Remove Modifier Operator
* \{ */
static int modifier_remove_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
int mode_orig = ob->mode;
if (md == NULL) {
return OPERATOR_CANCELLED;
}
/* Store name temporarily for report. */
char name[MAX_NAME];
strcpy(name, md->name);
if (!ED_object_modifier_remove(op->reports, bmain, scene, ob, md)) {
return OPERATOR_CANCELLED;
}
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
/* if cloth/softbody was removed, particle mode could be cleared */
if (mode_orig & OB_MODE_PARTICLE_EDIT) {
if ((ob->mode & OB_MODE_PARTICLE_EDIT) == 0) {
if (ob == OBACT(view_layer)) {
WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
}
}
}
if (RNA_boolean_get(op->ptr, "report")) {
BKE_reportf(op->reports, RPT_INFO, "Removed modifier: %s", name);
}
return OPERATOR_FINISHED;
}
static int modifier_remove_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_remove_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
void OBJECT_OT_modifier_remove(wmOperatorType *ot)
{
ot->name = "Remove Modifier";
ot->description = "Remove a modifier from the active object";
ot->idname = "OBJECT_OT_modifier_remove";
ot->invoke = modifier_remove_invoke;
ot->exec = modifier_remove_exec;
ot->poll = edit_modifier_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
edit_modifier_report_property(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Move Up Modifier Operator
* \{ */
static int modifier_move_up_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
if (!md || !ED_object_modifier_move_up(op->reports, ob, md)) {
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int modifier_move_up_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_move_up_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
void OBJECT_OT_modifier_move_up(wmOperatorType *ot)
{
ot->name = "Move Up Modifier";
ot->description = "Move modifier up in the stack";
ot->idname = "OBJECT_OT_modifier_move_up";
ot->invoke = modifier_move_up_invoke;
ot->exec = modifier_move_up_exec;
ot->poll = edit_modifier_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Move Down Modifier Operator
* \{ */
static int modifier_move_down_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
if (!md || !ED_object_modifier_move_down(op->reports, ob, md)) {
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int modifier_move_down_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_move_down_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
void OBJECT_OT_modifier_move_down(wmOperatorType *ot)
{
ot->name = "Move Down Modifier";
ot->description = "Move modifier down in the stack";
ot->idname = "OBJECT_OT_modifier_move_down";
ot->invoke = modifier_move_down_invoke;
ot->exec = modifier_move_down_exec;
ot->poll = edit_modifier_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Move to Index Modifier Operator
* \{ */
static int modifier_move_to_index_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
int index = RNA_int_get(op->ptr, "index");
if (!ED_object_modifier_move_to_index(op->reports, ob, md, index)) {
return OPERATOR_CANCELLED;
}
return OPERATOR_FINISHED;
}
static int modifier_move_to_index_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_move_to_index_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_modifier_move_to_index(wmOperatorType *ot)
{
ot->name = "Move Active Modifier to Index";
ot->description =
"Change the modifier's index in the stack so it evaluates after the set number of others";
ot->idname = "OBJECT_OT_modifier_move_to_index";
ot->invoke = modifier_move_to_index_invoke;
ot->exec = modifier_move_to_index_exec;
ot->poll = edit_modifier_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
RNA_def_int(
ot->srna, "index", 0, 0, INT_MAX, "Index", "The index to move the modifier to", 0, INT_MAX);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Apply Modifier Operator
* \{ */
static bool modifier_apply_poll_ex(bContext *C, bool allow_shared)
{
if (!edit_modifier_poll_generic(C, &RNA_Modifier, 0, false, false)) {
return false;
}
Scene *scene = CTX_data_scene(C);
PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
Object *ob = (ptr.owner_id != NULL) ? (Object *)ptr.owner_id : ED_object_active_context(C);
ModifierData *md = ptr.data; /* May be NULL. */
if (ID_IS_OVERRIDE_LIBRARY(ob) || ((ob->data != NULL) && ID_IS_OVERRIDE_LIBRARY(ob->data))) {
CTX_wm_operator_poll_msg_set(C, "Modifiers cannot be applied on override data");
return false;
}
if (!allow_shared && (ob->data != NULL) && ID_REAL_USERS(ob->data) > 1) {
CTX_wm_operator_poll_msg_set(C, "Modifiers cannot be applied to multi-user data");
return false;
}
if (md != NULL) {
if ((ob->mode & OB_MODE_SCULPT) && (find_multires_modifier_before(scene, md)) &&
(BKE_modifier_is_same_topology(md) == false)) {
CTX_wm_operator_poll_msg_set(
C, "Constructive modifier cannot be applied to multi-res data in sculpt mode");
return false;
}
}
return true;
}
static bool modifier_apply_poll(bContext *C)
{
return modifier_apply_poll_ex(C, false);
}
static int modifier_apply_exec_ex(bContext *C, wmOperator *op, int apply_as, bool keep_modifier)
{
Main *bmain = CTX_data_main(C);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Scene *scene = CTX_data_scene(C);
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
if (md == NULL) {
return OPERATOR_CANCELLED;
}
/* Store name temporarily for report. */
char name[MAX_NAME];
strcpy(name, md->name);
if (!ED_object_modifier_apply(
bmain, op->reports, depsgraph, scene, ob, md, apply_as, keep_modifier)) {
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
DEG_relations_tag_update(bmain);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
if (RNA_boolean_get(op->ptr, "report")) {
BKE_reportf(op->reports, RPT_INFO, "Applied modifier: %s", name);
}
return OPERATOR_FINISHED;
}
static int modifier_apply_exec(bContext *C, wmOperator *op)
{
return modifier_apply_exec_ex(C, op, MODIFIER_APPLY_DATA, false);
}
static int modifier_apply_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_apply_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
void OBJECT_OT_modifier_apply(wmOperatorType *ot)
{
ot->name = "Apply Modifier";
ot->description = "Apply modifier and remove from the stack";
ot->idname = "OBJECT_OT_modifier_apply";
ot->invoke = modifier_apply_invoke;
ot->exec = modifier_apply_exec;
ot->poll = modifier_apply_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
edit_modifier_report_property(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Apply Modifier As Shapekey Operator
* \{ */
static bool modifier_apply_as_shapekey_poll(bContext *C)
{
return modifier_apply_poll_ex(C, true);
}
static int modifier_apply_as_shapekey_exec(bContext *C, wmOperator *op)
{
bool keep = RNA_boolean_get(op->ptr, "keep_modifier");
return modifier_apply_exec_ex(C, op, MODIFIER_APPLY_SHAPE, keep);
}
static int modifier_apply_as_shapekey_invoke(bContext *C,
wmOperator *op,
const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_apply_as_shapekey_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
static char *modifier_apply_as_shapekey_get_description(struct bContext *UNUSED(C),
struct wmOperatorType *UNUSED(op),
struct PointerRNA *values)
{
bool keep = RNA_boolean_get(values, "keep_modifier");
if (keep) {
return BLI_strdup("Apply modifier as a new shapekey and keep it in the stack");
}
return NULL;
}
void OBJECT_OT_modifier_apply_as_shapekey(wmOperatorType *ot)
{
ot->name = "Apply Modifier as Shape Key";
ot->description = "Apply modifier as a new shape key and remove from the stack";
ot->idname = "OBJECT_OT_modifier_apply_as_shapekey";
ot->invoke = modifier_apply_as_shapekey_invoke;
ot->exec = modifier_apply_as_shapekey_exec;
ot->poll = modifier_apply_as_shapekey_poll;
ot->get_description = modifier_apply_as_shapekey_get_description;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
RNA_def_boolean(
ot->srna, "keep_modifier", false, "Keep Modifier", "Do not remove the modifier from stack");
edit_modifier_properties(ot);
edit_modifier_report_property(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Convert Modifier Operator
* \{ */
static int modifier_convert_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
if (!md || !ED_object_modifier_convert(op->reports, bmain, depsgraph, view_layer, ob, md)) {
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int modifier_convert_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_convert_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_modifier_convert(wmOperatorType *ot)
{
ot->name = "Convert Modifier";
ot->description = "Convert particles to a mesh object";
ot->idname = "OBJECT_OT_modifier_convert";
ot->invoke = modifier_convert_invoke;
ot->exec = modifier_convert_exec;
ot->poll = edit_modifier_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Copy Modifier Operator
* \{ */
static int modifier_copy_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
if (!md || !ED_object_modifier_copy(op->reports, bmain, scene, ob, md)) {
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int modifier_copy_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_copy_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
void OBJECT_OT_modifier_copy(wmOperatorType *ot)
{
ot->name = "Copy Modifier";
ot->description = "Duplicate modifier at the same position in the stack";
ot->idname = "OBJECT_OT_modifier_copy";
ot->invoke = modifier_copy_invoke;
ot->exec = modifier_copy_exec;
ot->poll = edit_modifier_liboverride_allowed_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Set Active Modifier Operator
* \{ */
static int modifier_set_active_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, ob, 0);
/* If there is no modifier set for this operator, clear the active modifier field. */
BKE_object_modifier_set_active(ob, md);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
/**
* Get the modifier below the mouse cursor modifier without checking the context pointer.
* Used in order to set the active modifier on mouse click. If this checked the context
* pointer then it would always set the active modifier to the already active modifier.
*
* \param event: If this isn't NULL, the operator will also look for panels underneath
* the cursor with custom-data set to a modifier.
* \param r_retval: This should be used if #event is used in order to return
* #OPERATOR_PASS_THROUGH to check other operators with the same key set.
*/
bool edit_modifier_invoke_properties_with_hover_no_active(bContext *C,
wmOperator *op,
const wmEvent *event,
int *r_retval)
{
if (RNA_struct_property_is_set(op->ptr, "modifier")) {
return true;
}
PointerRNA *panel_ptr = UI_region_panel_custom_data_under_cursor(C, event);
if (!(panel_ptr == NULL || RNA_pointer_is_null(panel_ptr))) {
if (RNA_struct_is_a(panel_ptr->type, &RNA_Modifier)) {
ModifierData *md = panel_ptr->data;
RNA_string_set(op->ptr, "modifier", md->name);
return true;
}
BLI_assert(r_retval != NULL); /* We need the return value in this case. */
if (r_retval != NULL) {
*r_retval = (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
return false;
}
if (r_retval != NULL) {
*r_retval = OPERATOR_CANCELLED;
}
return false;
}
static int modifier_set_active_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
int retval;
if (edit_modifier_invoke_properties_with_hover_no_active(C, op, event, &retval)) {
return modifier_set_active_exec(C, op);
}
return retval;
}
void OBJECT_OT_modifier_set_active(wmOperatorType *ot)
{
ot->name = "Set Active Modifier";
ot->description = "Activate the modifier to use as the context";
ot->idname = "OBJECT_OT_modifier_set_active";
ot->invoke = modifier_set_active_invoke;
ot->exec = modifier_set_active_exec;
ot->poll = edit_modifier_liboverride_allowed_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/** \name Copy Modifier To Selected Operator
* \{ */
static int modifier_copy_to_selected_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
Object *obact = ED_object_active_context(C);
ModifierData *md = edit_modifier_property_get(op, obact, 0);
if (!md) {
return OPERATOR_CANCELLED;
}
int num_copied = 0;
const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
if (ob == obact) {
continue;
}
/* Checked in #BKE_object_copy_modifier, but check here too so we can give a better message. */
if (!BKE_object_support_modifier_type_check(ob, md->type)) {
BKE_reportf(op->reports,
RPT_WARNING,
"Object '%s' does not support %s modifiers",
ob->id.name + 2,
mti->name);
continue;
}
if (mti->flags & eModifierTypeFlag_Single) {
if (BKE_modifiers_findby_type(ob, md->type)) {
BKE_reportf(op->reports,
RPT_WARNING,
"Modifier can only be added once to object '%s'",
ob->id.name + 2);
continue;
}
}
if (!BKE_object_copy_modifier(bmain, scene, ob, obact, md)) {
BKE_reportf(op->reports,
RPT_ERROR,
"Copying modifier '%s' to object '%s' failed",
md->name,
ob->id.name + 2);
}
num_copied++;
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
}
CTX_DATA_END;
if (num_copied > 0) {
DEG_relations_tag_update(bmain);
}
else {
BKE_reportf(op->reports, RPT_ERROR, "Modifier '%s' was not copied to any objects", md->name);
return OPERATOR_CANCELLED;
}
return OPERATOR_FINISHED;
}
static int modifier_copy_to_selected_invoke(bContext *C,
wmOperator *op,
const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return modifier_copy_to_selected_exec(C, op);
}
/* Work around multiple operators using the same shortcut. */
return (OPERATOR_PASS_THROUGH | OPERATOR_CANCELLED);
}
static bool modifier_copy_to_selected_poll(bContext *C)
{
PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_Modifier);
Object *obact = (ptr.owner_id) ? (Object *)ptr.owner_id : ED_object_active_context(C);
ModifierData *md = ptr.data;
/* This just mirrors the check in #BKE_object_copy_modifier,
* but there is no reasoning for it there. */
if (md && ELEM(md->type, eModifierType_Hook, eModifierType_Collision)) {
CTX_wm_operator_poll_msg_set(C, "Not supported for \"Collision\" or \"Hook\" modifiers");
return false;
}
if (!obact) {
CTX_wm_operator_poll_msg_set(C, "No selected object is active");
return false;
}
if (!BKE_object_supports_modifiers(obact)) {
CTX_wm_operator_poll_msg_set(C, "Object type of source object is not supported");
return false;
}
/* This could have a performance impact in the worst case, where there are many objects selected
* and none of them pass either of the checks. But that should be uncommon, and this operator is
* only exposed in a drop-down menu anyway. */
bool found_supported_objects = false;
CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
if (ob == obact) {
continue;
}
if (!md && BKE_object_supports_modifiers(ob)) {
/* Skip type check if modifier could not be found ("modifier" context variable not set). */
found_supported_objects = true;
break;
}
if (BKE_object_support_modifier_type_check(ob, md->type)) {
found_supported_objects = true;
break;
}
}
CTX_DATA_END;
if (!found_supported_objects) {
CTX_wm_operator_poll_msg_set(C, "No supported objects were selected");
return false;
}
return true;
}
void OBJECT_OT_modifier_copy_to_selected(wmOperatorType *ot)
{
ot->name = "Copy Modifier to Selected";
ot->description = "Copy the modifier from the active object to all selected objects";
ot->idname = "OBJECT_OT_modifier_copy_to_selected";
ot->invoke = modifier_copy_to_selected_invoke;
ot->exec = modifier_copy_to_selected_exec;
ot->poll = modifier_copy_to_selected_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Delete Higher Levels Operator
* \{ */
static bool multires_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_MultiresModifier, (1 << OB_MESH), true, false);
}
static int multires_higher_levels_delete_exec(bContext *C, wmOperator *op)
{
Scene *scene = CTX_data_scene(C);
Object *ob = ED_object_active_context(C);
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, ob, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
multiresModifier_del_levels(mmd, scene, ob, 1);
ED_object_iter_other(
CTX_data_main(C), ob, true, ED_object_multires_update_totlevels_cb, &mmd->totlvl);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int multires_higher_levels_delete_invoke(bContext *C,
wmOperator *op,
const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_higher_levels_delete_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_higher_levels_delete(wmOperatorType *ot)
{
ot->name = "Delete Higher Levels";
ot->description = "Deletes the higher resolution mesh, potential loss of detail";
ot->idname = "OBJECT_OT_multires_higher_levels_delete";
ot->poll = multires_poll;
ot->invoke = multires_higher_levels_delete_invoke;
ot->exec = multires_higher_levels_delete_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Subdivide Operator
* \{ */
static EnumPropertyItem prop_multires_subdivide_mode_type[] = {
{MULTIRES_SUBDIVIDE_CATMULL_CLARK,
"CATMULL_CLARK",
0,
"Catmull-Clark",
"Create a new level using Catmull-Clark subdivisions"},
{MULTIRES_SUBDIVIDE_SIMPLE,
"SIMPLE",
0,
"Simple",
"Create a new level using simple subdivisions"},
{MULTIRES_SUBDIVIDE_LINEAR,
"LINEAR",
0,
"Linear",
"Create a new level using linear interpolation of the sculpted displacement"},
{0, NULL, 0, NULL, NULL},
};
static int multires_subdivide_exec(bContext *C, wmOperator *op)
{
Object *object = ED_object_active_context(C);
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, object, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
const eMultiresSubdivideModeType subdivide_mode = (eMultiresSubdivideModeType)(
RNA_enum_get(op->ptr, "mode"));
multiresModifier_subdivide(object, mmd, subdivide_mode);
ED_object_iter_other(
CTX_data_main(C), object, true, ED_object_multires_update_totlevels_cb, &mmd->totlvl);
DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object);
if (object->mode & OB_MODE_SCULPT) {
/* ensure that grid paint mask layer is created */
BKE_sculpt_mask_layers_ensure(object, mmd);
}
return OPERATOR_FINISHED;
}
static int multires_subdivide_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_subdivide_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_subdivide(wmOperatorType *ot)
{
ot->name = "Multires Subdivide";
ot->description = "Add a new level of subdivision";
ot->idname = "OBJECT_OT_multires_subdivide";
ot->poll = multires_poll;
ot->invoke = multires_subdivide_invoke;
ot->exec = multires_subdivide_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
RNA_def_enum(ot->srna,
"mode",
prop_multires_subdivide_mode_type,
MULTIRES_SUBDIVIDE_CATMULL_CLARK,
"Subdivision Mode",
"How the mesh is going to be subdivided to create a new level");
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Reshape Operator
* \{ */
static int multires_reshape_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Object *ob = ED_object_active_context(C), *secondob = NULL;
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, ob, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
if (mmd->lvl == 0) {
BKE_report(op->reports, RPT_ERROR, "Reshape can work only with higher levels of subdivisions");
return OPERATOR_CANCELLED;
}
CTX_DATA_BEGIN (C, Object *, selob, selected_editable_objects) {
if (selob->type == OB_MESH && selob != ob) {
secondob = selob;
break;
}
}
CTX_DATA_END;
if (!secondob) {
BKE_report(op->reports, RPT_ERROR, "Second selected mesh object required to copy shape from");
return OPERATOR_CANCELLED;
}
if (!multiresModifier_reshapeFromObject(depsgraph, mmd, ob, secondob)) {
BKE_report(op->reports, RPT_ERROR, "Objects do not have the same number of vertices");
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int multires_reshape_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_reshape_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_reshape(wmOperatorType *ot)
{
ot->name = "Multires Reshape";
ot->description = "Copy vertex coordinates from other object";
ot->idname = "OBJECT_OT_multires_reshape";
ot->poll = multires_poll;
ot->invoke = multires_reshape_invoke;
ot->exec = multires_reshape_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Save External Operator
* \{ */
static int multires_external_save_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Object *ob = ED_object_active_context(C);
Mesh *me = (ob) ? ob->data : op->customdata;
char path[FILE_MAX];
const bool relative = RNA_boolean_get(op->ptr, "relative_path");
if (!me) {
return OPERATOR_CANCELLED;
}
if (CustomData_external_test(&me->ldata, CD_MDISPS)) {
return OPERATOR_CANCELLED;
}
RNA_string_get(op->ptr, "filepath", path);
if (relative) {
BLI_path_rel(path, BKE_main_blendfile_path(bmain));
}
CustomData_external_add(&me->ldata, &me->id, CD_MDISPS, me->totloop, path);
CustomData_external_write(&me->ldata, &me->id, CD_MASK_MESH.lmask, me->totloop, 0);
return OPERATOR_FINISHED;
}
static int multires_external_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
Object *ob = ED_object_active_context(C);
Mesh *me = ob->data;
char path[FILE_MAX];
if (!edit_modifier_invoke_properties(C, op)) {
return OPERATOR_CANCELLED;
}
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, ob, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
if (CustomData_external_test(&me->ldata, CD_MDISPS)) {
return OPERATOR_CANCELLED;
}
if (RNA_struct_property_is_set(op->ptr, "filepath")) {
return multires_external_save_exec(C, op);
}
op->customdata = me;
BLI_snprintf(path, sizeof(path), "//%s.btx", me->id.name + 2);
RNA_string_set(op->ptr, "filepath", path);
WM_event_add_fileselect(C, op);
return OPERATOR_RUNNING_MODAL;
}
void OBJECT_OT_multires_external_save(wmOperatorType *ot)
{
ot->name = "Multires Save External";
ot->description = "Save displacements to an external file";
ot->idname = "OBJECT_OT_multires_external_save";
/* XXX modifier no longer in context after file browser .. ot->poll = multires_poll; */
ot->exec = multires_external_save_exec;
ot->invoke = multires_external_save_invoke;
ot->poll = multires_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
WM_operator_properties_filesel(ot,
FILE_TYPE_FOLDER | FILE_TYPE_BTX,
FILE_SPECIAL,
FILE_SAVE,
WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH,
FILE_DEFAULTDISPLAY,
FILE_SORT_DEFAULT);
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Pack Operator
* \{ */
static int multires_external_pack_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_active_context(C);
Mesh *me = ob->data;
if (!CustomData_external_test(&me->ldata, CD_MDISPS)) {
return OPERATOR_CANCELLED;
}
/* XXX don't remove.. */
CustomData_external_remove(&me->ldata, &me->id, CD_MDISPS, me->totloop);
return OPERATOR_FINISHED;
}
void OBJECT_OT_multires_external_pack(wmOperatorType *ot)
{
ot->name = "Multires Pack External";
ot->description = "Pack displacements from an external file";
ot->idname = "OBJECT_OT_multires_external_pack";
ot->poll = multires_poll;
ot->exec = multires_external_pack_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Apply Base
* \{ */
static int multires_base_apply_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
Object *object = ED_object_active_context(C);
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, object, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
ED_sculpt_undo_push_multires_mesh_begin(C, op->type->name);
multiresModifier_base_apply(depsgraph, object, mmd);
ED_sculpt_undo_push_multires_mesh_end(C, op->type->name);
DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object);
return OPERATOR_FINISHED;
}
static int multires_base_apply_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_base_apply_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_base_apply(wmOperatorType *ot)
{
ot->name = "Multires Apply Base";
ot->description = "Modify the base mesh to conform to the displaced mesh";
ot->idname = "OBJECT_OT_multires_base_apply";
ot->poll = multires_poll;
ot->invoke = multires_base_apply_invoke;
ot->exec = multires_base_apply_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Unsubdivide
* \{ */
static int multires_unsubdivide_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
Object *object = ED_object_active_context(C);
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, object, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
int new_levels = multiresModifier_rebuild_subdiv(depsgraph, object, mmd, 1, true);
if (new_levels == 0) {
BKE_report(op->reports, RPT_ERROR, "Not valid subdivisions found to rebuild a lower level");
return OPERATOR_CANCELLED;
}
DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object);
return OPERATOR_FINISHED;
}
static int multires_unsubdivide_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_unsubdivide_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_unsubdivide(wmOperatorType *ot)
{
ot->name = "Unsubdivide";
ot->description = "Rebuild a lower subdivision level of the current base mesh";
ot->idname = "OBJECT_OT_multires_unsubdivide";
ot->poll = multires_poll;
ot->invoke = multires_unsubdivide_invoke;
ot->exec = multires_unsubdivide_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Multires Rebuild Subdivisions
* \{ */
static int multires_rebuild_subdiv_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
Object *object = ED_object_active_context(C);
MultiresModifierData *mmd = (MultiresModifierData *)edit_modifier_property_get(
op, object, eModifierType_Multires);
if (!mmd) {
return OPERATOR_CANCELLED;
}
int new_levels = multiresModifier_rebuild_subdiv(depsgraph, object, mmd, INT_MAX, false);
if (new_levels == 0) {
BKE_report(op->reports, RPT_ERROR, "Not valid subdivisions found to rebuild lower levels");
return OPERATOR_CANCELLED;
}
BKE_reportf(op->reports, RPT_INFO, "%d new levels rebuilt", new_levels);
DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, object);
return OPERATOR_FINISHED;
}
static int multires_rebuild_subdiv_invoke(bContext *C,
wmOperator *op,
const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return multires_rebuild_subdiv_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_multires_rebuild_subdiv(wmOperatorType *ot)
{
ot->name = "Rebuild Lower Subdivisions";
ot->description =
"Rebuilds all possible subdivisions levels to generate a lower resolution base mesh";
ot->idname = "OBJECT_OT_multires_rebuild_subdiv";
ot->poll = multires_poll;
ot->invoke = multires_rebuild_subdiv_invoke;
ot->exec = multires_rebuild_subdiv_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Skin Modifier
* \{ */
static void modifier_skin_customdata_delete(Object *ob)
{
Mesh *me = ob->data;
BMEditMesh *em = me->edit_mesh;
if (em) {
BM_data_layer_free(em->bm, &em->bm->vdata, CD_MVERT_SKIN);
}
else {
CustomData_free_layer_active(&me->vdata, CD_MVERT_SKIN, me->totvert);
}
}
static bool skin_poll(bContext *C)
{
return (edit_modifier_poll_generic(C, &RNA_SkinModifier, (1 << OB_MESH), false, false));
}
static bool skin_edit_poll(bContext *C)
{
Object *ob = CTX_data_edit_object(C);
return (ob != NULL &&
edit_modifier_poll_generic(C, &RNA_SkinModifier, (1 << OB_MESH), true, false) &&
!ID_IS_OVERRIDE_LIBRARY(ob) && !ID_IS_OVERRIDE_LIBRARY(ob->data));
}
static void skin_root_clear(BMVert *bm_vert, GSet *visited, const int cd_vert_skin_offset)
{
BMEdge *bm_edge;
BMIter bm_iter;
BM_ITER_ELEM (bm_edge, &bm_iter, bm_vert, BM_EDGES_OF_VERT) {
BMVert *v2 = BM_edge_other_vert(bm_edge, bm_vert);
if (BLI_gset_add(visited, v2)) {
MVertSkin *vs = BM_ELEM_CD_GET_VOID_P(v2, cd_vert_skin_offset);
/* clear vertex root flag and add to visited set */
vs->flag &= ~MVERT_SKIN_ROOT;
skin_root_clear(v2, visited, cd_vert_skin_offset);
}
}
}
static int skin_root_mark_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = CTX_data_edit_object(C);
BMEditMesh *em = BKE_editmesh_from_object(ob);
BMesh *bm = em->bm;
GSet *visited = BLI_gset_ptr_new(__func__);
BKE_mesh_ensure_skin_customdata(ob->data);
const int cd_vert_skin_offset = CustomData_get_offset(&bm->vdata, CD_MVERT_SKIN);
BMVert *bm_vert;
BMIter bm_iter;
BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT) && BLI_gset_add(visited, bm_vert)) {
MVertSkin *vs = BM_ELEM_CD_GET_VOID_P(bm_vert, cd_vert_skin_offset);
/* mark vertex as root and add to visited set */
vs->flag |= MVERT_SKIN_ROOT;
/* clear root flag from all connected vertices (recursively) */
skin_root_clear(bm_vert, visited, cd_vert_skin_offset);
}
}
BLI_gset_free(visited, NULL);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
void OBJECT_OT_skin_root_mark(wmOperatorType *ot)
{
ot->name = "Skin Root Mark";
ot->description = "Mark selected vertices as roots";
ot->idname = "OBJECT_OT_skin_root_mark";
ot->poll = skin_edit_poll;
ot->exec = skin_root_mark_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
typedef enum {
SKIN_LOOSE_MARK,
SKIN_LOOSE_CLEAR,
} SkinLooseAction;
static int skin_loose_mark_clear_exec(bContext *C, wmOperator *op)
{
Object *ob = CTX_data_edit_object(C);
BMEditMesh *em = BKE_editmesh_from_object(ob);
BMesh *bm = em->bm;
SkinLooseAction action = RNA_enum_get(op->ptr, "action");
if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
return OPERATOR_CANCELLED;
}
BMVert *bm_vert;
BMIter bm_iter;
BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
MVertSkin *vs = CustomData_bmesh_get(&bm->vdata, bm_vert->head.data, CD_MVERT_SKIN);
switch (action) {
case SKIN_LOOSE_MARK:
vs->flag |= MVERT_SKIN_LOOSE;
break;
case SKIN_LOOSE_CLEAR:
vs->flag &= ~MVERT_SKIN_LOOSE;
break;
}
}
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
void OBJECT_OT_skin_loose_mark_clear(wmOperatorType *ot)
{
static const EnumPropertyItem action_items[] = {
{SKIN_LOOSE_MARK, "MARK", 0, "Mark", "Mark selected vertices as loose"},
{SKIN_LOOSE_CLEAR, "CLEAR", 0, "Clear", "Set selected vertices as not loose"},
{0, NULL, 0, NULL, NULL},
};
ot->name = "Skin Mark/Clear Loose";
ot->description = "Mark/clear selected vertices as loose";
ot->idname = "OBJECT_OT_skin_loose_mark_clear";
ot->poll = skin_edit_poll;
ot->exec = skin_loose_mark_clear_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
RNA_def_enum(ot->srna, "action", action_items, SKIN_LOOSE_MARK, "Action", NULL);
}
static int skin_radii_equalize_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = CTX_data_edit_object(C);
BMEditMesh *em = BKE_editmesh_from_object(ob);
BMesh *bm = em->bm;
if (!CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN)) {
return OPERATOR_CANCELLED;
}
BMVert *bm_vert;
BMIter bm_iter;
BM_ITER_MESH (bm_vert, &bm_iter, bm, BM_VERTS_OF_MESH) {
if (BM_elem_flag_test(bm_vert, BM_ELEM_SELECT)) {
MVertSkin *vs = CustomData_bmesh_get(&bm->vdata, bm_vert->head.data, CD_MVERT_SKIN);
float avg = (vs->radius[0] + vs->radius[1]) * 0.5f;
vs->radius[0] = vs->radius[1] = avg;
}
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
void OBJECT_OT_skin_radii_equalize(wmOperatorType *ot)
{
ot->name = "Skin Radii Equalize";
ot->description = "Make skin radii of selected vertices equal on each axis";
ot->idname = "OBJECT_OT_skin_radii_equalize";
ot->poll = skin_edit_poll;
ot->exec = skin_radii_equalize_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static void skin_armature_bone_create(Object *skin_ob,
MVert *mvert,
MEdge *medge,
bArmature *arm,
BLI_bitmap *edges_visited,
const MeshElemMap *emap,
EditBone *parent_bone,
int parent_v)
{
for (int i = 0; i < emap[parent_v].count; i++) {
int endx = emap[parent_v].indices[i];
const MEdge *e = &medge[endx];
/* ignore edge if already visited */
if (BLI_BITMAP_TEST(edges_visited, endx)) {
continue;
}
BLI_BITMAP_ENABLE(edges_visited, endx);
int v = (e->v1 == parent_v ? e->v2 : e->v1);
EditBone *bone = ED_armature_ebone_add(arm, "Bone");
bone->parent = parent_bone;
if (parent_bone != NULL) {
bone->flag |= BONE_CONNECTED;
}
copy_v3_v3(bone->head, mvert[parent_v].co);
copy_v3_v3(bone->tail, mvert[v].co);
bone->rad_head = bone->rad_tail = 0.25;
BLI_snprintf(bone->name, sizeof(bone->name), "Bone.%.2d", endx);
/* add bDeformGroup */
bDeformGroup *dg = BKE_object_defgroup_add_name(skin_ob, bone->name);
if (dg != NULL) {
ED_vgroup_vert_add(skin_ob, dg, parent_v, 1, WEIGHT_REPLACE);
ED_vgroup_vert_add(skin_ob, dg, v, 1, WEIGHT_REPLACE);
}
skin_armature_bone_create(skin_ob, mvert, medge, arm, edges_visited, emap, bone, v);
}
}
static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain, Object *skin_ob)
{
Mesh *me = skin_ob->data;
Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
Object *ob_eval = DEG_get_evaluated_object(depsgraph, skin_ob);
Mesh *me_eval_deform = mesh_get_eval_deform(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
MVert *mvert = me_eval_deform->mvert;
/* add vertex weights to original mesh */
CustomData_add_layer(&me->vdata, CD_MDEFORMVERT, CD_CALLOC, NULL, me->totvert);
ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
Object *arm_ob = BKE_object_add(bmain, view_layer, OB_ARMATURE, NULL);
BKE_object_transform_copy(arm_ob, skin_ob);
bArmature *arm = arm_ob->data;
arm->layer = 1;
arm_ob->dtx |= OB_DRAW_IN_FRONT;
arm->drawtype = ARM_LINE;
arm->edbo = MEM_callocN(sizeof(ListBase), "edbo armature");
MVertSkin *mvert_skin = CustomData_get_layer(&me->vdata, CD_MVERT_SKIN);
int *emap_mem;
MeshElemMap *emap;
BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me->medge, me->totvert, me->totedge);
BLI_bitmap *edges_visited = BLI_BITMAP_NEW(me->totedge, "edge_visited");
/* note: we use EditBones here, easier to set them up and use
* edit-armature functions to convert back to regular bones */
for (int v = 0; v < me->totvert; v++) {
if (mvert_skin[v].flag & MVERT_SKIN_ROOT) {
EditBone *bone = NULL;
/* Unless the skin root has just one adjacent edge, create
* a fake root bone (have it going off in the Y direction
* (arbitrary) */
if (emap[v].count > 1) {
bone = ED_armature_ebone_add(arm, "Bone");
copy_v3_v3(bone->head, me->mvert[v].co);
copy_v3_v3(bone->tail, me->mvert[v].co);
bone->head[1] = 1.0f;
bone->rad_head = bone->rad_tail = 0.25;
}
if (emap[v].count >= 1) {
skin_armature_bone_create(skin_ob, mvert, me->medge, arm, edges_visited, emap, bone, v);
}
}
}
MEM_freeN(edges_visited);
MEM_freeN(emap);
MEM_freeN(emap_mem);
ED_armature_from_edit(bmain, arm);
ED_armature_edit_free(arm);
return arm_ob;
}
static int skin_armature_create_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Object *ob = CTX_data_active_object(C);
Mesh *me = ob->data;
ModifierData *skin_md;
if (!CustomData_has_layer(&me->vdata, CD_MVERT_SKIN)) {
BKE_reportf(op->reports, RPT_WARNING, "Mesh '%s' has no skin vertex data", me->id.name + 2);
return OPERATOR_CANCELLED;
}
/* create new armature */
Object *arm_ob = modifier_skin_armature_create(depsgraph, bmain, ob);
/* add a modifier to connect the new armature to the mesh */
ArmatureModifierData *arm_md = (ArmatureModifierData *)BKE_modifier_new(eModifierType_Armature);
if (arm_md) {
skin_md = edit_modifier_property_get(op, ob, eModifierType_Skin);
BLI_insertlinkafter(&ob->modifiers, skin_md, arm_md);
arm_md->object = arm_ob;
arm_md->deformflag = ARM_DEF_VGROUP | ARM_DEF_QUATERNION;
DEG_relations_tag_update(bmain);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
}
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int skin_armature_create_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return skin_armature_create_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_skin_armature_create(wmOperatorType *ot)
{
ot->name = "Skin Armature Create";
ot->description = "Create an armature that parallels the skin layout";
ot->idname = "OBJECT_OT_skin_armature_create";
ot->poll = skin_poll;
ot->invoke = skin_armature_create_invoke;
ot->exec = skin_armature_create_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Delta Mesh Bind Operator
* \{ */
static bool correctivesmooth_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_CorrectiveSmoothModifier, 0, true, false);
}
static int correctivesmooth_bind_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Scene *scene = CTX_data_scene(C);
Object *ob = ED_object_active_context(C);
CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)edit_modifier_property_get(
op, ob, eModifierType_CorrectiveSmooth);
if (!csmd) {
return OPERATOR_CANCELLED;
}
if (!BKE_modifier_is_enabled(scene, &csmd->modifier, eModifierMode_Realtime)) {
BKE_report(op->reports, RPT_ERROR, "Modifier is disabled");
return OPERATOR_CANCELLED;
}
const bool is_bind = (csmd->bind_coords != NULL);
MEM_SAFE_FREE(csmd->bind_coords);
MEM_SAFE_FREE(csmd->delta_cache.deltas);
if (is_bind) {
/* toggle off */
csmd->bind_coords_num = 0;
}
else {
/* Signal to modifier to recalculate. */
CorrectiveSmoothModifierData *csmd_eval = (CorrectiveSmoothModifierData *)
BKE_modifier_get_evaluated(depsgraph, ob, &csmd->modifier);
csmd_eval->bind_coords_num = (uint)-1;
/* Force modifier to run, it will call binding routine
* (this has to happen outside of depsgraph evaluation). */
object_force_modifier_bind_simple_options(depsgraph, ob, &csmd->modifier);
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int correctivesmooth_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return correctivesmooth_bind_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_correctivesmooth_bind(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Corrective Smooth Bind";
ot->description = "Bind base pose in Corrective Smooth modifier";
ot->idname = "OBJECT_OT_correctivesmooth_bind";
/* api callbacks */
ot->poll = correctivesmooth_poll;
ot->invoke = correctivesmooth_bind_invoke;
ot->exec = correctivesmooth_bind_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Mesh Deform Bind Operator
* \{ */
static bool meshdeform_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_MeshDeformModifier, 0, true, false);
}
static int meshdeform_bind_exec(bContext *C, wmOperator *op)
{
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Object *ob = ED_object_active_context(C);
MeshDeformModifierData *mmd = (MeshDeformModifierData *)edit_modifier_property_get(
op, ob, eModifierType_MeshDeform);
if (mmd == NULL) {
return OPERATOR_CANCELLED;
}
if (mmd->bindcagecos != NULL) {
MEM_SAFE_FREE(mmd->bindcagecos);
MEM_SAFE_FREE(mmd->dyngrid);
MEM_SAFE_FREE(mmd->dyninfluences);
MEM_SAFE_FREE(mmd->bindinfluences);
MEM_SAFE_FREE(mmd->bindoffsets);
MEM_SAFE_FREE(mmd->dynverts);
MEM_SAFE_FREE(mmd->bindweights); /* Deprecated */
MEM_SAFE_FREE(mmd->bindcos); /* Deprecated */
mmd->totvert = 0;
mmd->totcagevert = 0;
mmd->totinfluence = 0;
}
else {
/* Force modifier to run, it will call binding routine
* (this has to happen outside of depsgraph evaluation). */
MeshDeformModifierData *mmd_eval = (MeshDeformModifierData *)BKE_modifier_get_evaluated(
depsgraph, ob, &mmd->modifier);
mmd_eval->bindfunc = ED_mesh_deform_bind_callback;
object_force_modifier_bind_simple_options(depsgraph, ob, &mmd->modifier);
mmd_eval->bindfunc = NULL;
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int meshdeform_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return meshdeform_bind_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_meshdeform_bind(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Mesh Deform Bind";
ot->description = "Bind mesh to cage in mesh deform modifier";
ot->idname = "OBJECT_OT_meshdeform_bind";
/* api callbacks */
ot->poll = meshdeform_poll;
ot->invoke = meshdeform_bind_invoke;
ot->exec = meshdeform_bind_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Explode Refresh Operator
* \{ */
static bool explode_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_ExplodeModifier, 0, true, false);
}
static int explode_refresh_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
ExplodeModifierData *emd = (ExplodeModifierData *)edit_modifier_property_get(
op, ob, eModifierType_Explode);
if (!emd) {
return OPERATOR_CANCELLED;
}
emd->flag |= eExplodeFlag_CalcFaces;
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int explode_refresh_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return explode_refresh_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_explode_refresh(wmOperatorType *ot)
{
ot->name = "Explode Refresh";
ot->description = "Refresh data in the Explode modifier";
ot->idname = "OBJECT_OT_explode_refresh";
ot->poll = explode_poll;
ot->invoke = explode_refresh_invoke;
ot->exec = explode_refresh_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Ocean Bake Operator
* \{ */
static bool ocean_bake_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_OceanModifier, 0, true, false);
}
typedef struct OceanBakeJob {
/* from wmJob */
struct Object *owner;
short *stop, *do_update;
float *progress;
int current_frame;
struct OceanCache *och;
struct Ocean *ocean;
struct OceanModifierData *omd;
} OceanBakeJob;
static void oceanbake_free(void *customdata)
{
OceanBakeJob *oj = customdata;
MEM_freeN(oj);
}
/* called by oceanbake, only to check job 'stop' value */
static int oceanbake_breakjob(void *UNUSED(customdata))
{
// OceanBakeJob *ob = (OceanBakeJob *)customdata;
// return *(ob->stop);
/* this is not nice yet, need to make the jobs list template better
* for identifying/acting upon various different jobs */
/* but for now we'll reuse the render break... */
return (G.is_break);
}
/* called by oceanbake, wmJob sends notifier */
static void oceanbake_update(void *customdata, float progress, int *cancel)
{
OceanBakeJob *oj = customdata;
if (oceanbake_breakjob(oj)) {
*cancel = 1;
}
*(oj->do_update) = true;
*(oj->progress) = progress;
}
static void oceanbake_startjob(void *customdata, short *stop, short *do_update, float *progress)
{
OceanBakeJob *oj = customdata;
oj->stop = stop;
oj->do_update = do_update;
oj->progress = progress;
G.is_break = false; /* XXX shared with render - replace with job 'stop' switch */
BKE_ocean_bake(oj->ocean, oj->och, oceanbake_update, (void *)oj);
*do_update = true;
*stop = 0;
}
static void oceanbake_endjob(void *customdata)
{
OceanBakeJob *oj = customdata;
if (oj->ocean) {
BKE_ocean_free(oj->ocean);
oj->ocean = NULL;
}
oj->omd->oceancache = oj->och;
oj->omd->cached = true;
Object *ob = oj->owner;
DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
}
static int ocean_bake_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
Object *ob = ED_object_active_context(C);
OceanModifierData *omd = (OceanModifierData *)edit_modifier_property_get(
op, ob, eModifierType_Ocean);
Scene *scene = CTX_data_scene(C);
const bool free = RNA_boolean_get(op->ptr, "free");
if (!omd) {
return OPERATOR_CANCELLED;
}
if (free) {
BKE_ocean_free_modifier_cache(omd);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
OceanCache *och = BKE_ocean_init_cache(omd->cachepath,
BKE_modifier_path_relbase(bmain, ob),
omd->bakestart,
omd->bakeend,
omd->wave_scale,
omd->chop_amount,
omd->foam_coverage,
omd->foam_fade,
omd->resolution);
och->time = MEM_mallocN(och->duration * sizeof(float), "foam bake time");
int cfra = scene->r.cfra;
/* precalculate time variable before baking */
int i = 0;
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
for (int f = omd->bakestart; f <= omd->bakeend; f++) {
/* For now only simple animation of time value is supported, nothing else.
* No drivers or other modifier parameters. */
/* TODO(sergey): This operates on an original data, so no flush is needed. However, baking
* usually should happen on an evaluated objects, so this seems to be deeper issue here. */
const AnimationEvalContext anim_eval_context = BKE_animsys_eval_context_construct(depsgraph,
f);
BKE_animsys_evaluate_animdata((ID *)ob, ob->adt, &anim_eval_context, ADT_RECALC_ANIM, false);
och->time[i] = omd->time;
i++;
}
/* Make a copy of ocean to use for baking - thread-safety. */
struct Ocean *ocean = BKE_ocean_add();
BKE_ocean_init_from_modifier(ocean, omd, omd->resolution);
#if 0
BKE_ocean_bake(ocean, och);
omd->oceancache = och;
omd->cached = true;
scene->r.cfra = cfra;
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
#endif
/* job stuff */
scene->r.cfra = cfra;
/* setup job */
wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C),
CTX_wm_window(C),
scene,
"Ocean Simulation",
WM_JOB_PROGRESS,
WM_JOB_TYPE_OBJECT_SIM_OCEAN);
OceanBakeJob *oj = MEM_callocN(sizeof(OceanBakeJob), "ocean bake job");
oj->owner = ob;
oj->ocean = ocean;
oj->och = och;
oj->omd = omd;
WM_jobs_customdata_set(wm_job, oj, oceanbake_free);
WM_jobs_timer(wm_job, 0.1, NC_OBJECT | ND_MODIFIER, NC_OBJECT | ND_MODIFIER);
WM_jobs_callbacks(wm_job, oceanbake_startjob, NULL, NULL, oceanbake_endjob);
WM_jobs_start(CTX_wm_manager(C), wm_job);
return OPERATOR_FINISHED;
}
static int ocean_bake_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return ocean_bake_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_ocean_bake(wmOperatorType *ot)
{
ot->name = "Bake Ocean";
ot->description = "Bake an image sequence of ocean data";
ot->idname = "OBJECT_OT_ocean_bake";
ot->poll = ocean_bake_poll;
ot->invoke = ocean_bake_invoke;
ot->exec = ocean_bake_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
RNA_def_boolean(ot->srna, "free", false, "Free", "Free the bake, rather than generating it");
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Laplaciandeform Bind Operator
* \{ */
static bool laplaciandeform_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_LaplacianDeformModifier, 0, false, false);
}
static int laplaciandeform_bind_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
LaplacianDeformModifierData *lmd = (LaplacianDeformModifierData *)edit_modifier_property_get(
op, ob, eModifierType_LaplacianDeform);
if (lmd == NULL) {
return OPERATOR_CANCELLED;
}
if (lmd->flag & MOD_LAPLACIANDEFORM_BIND) {
lmd->flag &= ~MOD_LAPLACIANDEFORM_BIND;
}
else {
lmd->flag |= MOD_LAPLACIANDEFORM_BIND;
}
LaplacianDeformModifierData *lmd_eval = (LaplacianDeformModifierData *)
BKE_modifier_get_evaluated(depsgraph, ob, &lmd->modifier);
lmd_eval->flag = lmd->flag;
/* Force modifier to run, it will call binding routine
* (this has to happen outside of depsgraph evaluation). */
object_force_modifier_bind_simple_options(depsgraph, ob, &lmd->modifier);
/* This is hard to know from the modifier itself whether the evaluation is
* happening for binding or not. So we copy all the required data here. */
lmd->total_verts = lmd_eval->total_verts;
if (lmd_eval->vertexco == NULL) {
MEM_SAFE_FREE(lmd->vertexco);
}
else {
lmd->vertexco = MEM_dupallocN(lmd_eval->vertexco);
}
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int laplaciandeform_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return laplaciandeform_bind_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_laplaciandeform_bind(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Laplacian Deform Bind";
ot->description = "Bind mesh to system in laplacian deform modifier";
ot->idname = "OBJECT_OT_laplaciandeform_bind";
/* api callbacks */
ot->poll = laplaciandeform_poll;
ot->invoke = laplaciandeform_bind_invoke;
ot->exec = laplaciandeform_bind_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
/* ------------------------------------------------------------------- */
/** \name Surface Deform Bind Operator
* \{ */
static bool surfacedeform_bind_poll(bContext *C)
{
return edit_modifier_poll_generic(C, &RNA_SurfaceDeformModifier, 0, true, false);
}
static int surfacedeform_bind_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_active_context(C);
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
SurfaceDeformModifierData *smd = (SurfaceDeformModifierData *)edit_modifier_property_get(
op, ob, eModifierType_SurfaceDeform);
if (smd == NULL) {
return OPERATOR_CANCELLED;
}
if (smd->flags & MOD_SDEF_BIND) {
smd->flags &= ~MOD_SDEF_BIND;
}
else if (smd->target) {
smd->flags |= MOD_SDEF_BIND;
}
SurfaceDeformModifierData *smd_eval = (SurfaceDeformModifierData *)BKE_modifier_get_evaluated(
depsgraph, ob, &smd->modifier);
smd_eval->flags = smd->flags;
/* Force modifier to run, it will call binding routine
* (this has to happen outside of depsgraph evaluation). */
object_force_modifier_bind_simple_options(depsgraph, ob, &smd->modifier);
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
return OPERATOR_FINISHED;
}
static int surfacedeform_bind_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
if (edit_modifier_invoke_properties(C, op)) {
return surfacedeform_bind_exec(C, op);
}
return OPERATOR_CANCELLED;
}
void OBJECT_OT_surfacedeform_bind(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Surface Deform Bind";
ot->description = "Bind mesh to target in surface deform modifier";
ot->idname = "OBJECT_OT_surfacedeform_bind";
/* api callbacks */
ot->poll = surfacedeform_bind_poll;
ot->invoke = surfacedeform_bind_invoke;
ot->exec = surfacedeform_bind_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
edit_modifier_properties(ot);
}
/** \} */
|
508921.c | /* ************************************************************************
* File: augments.c EmpireMUD 2.0b5 *
* Usage: DB and OLC for augments (item enchantments) *
* *
* EmpireMUD code base by Paul Clarke, (C) 2000-2015 *
* All rights reserved. See license.doc for complete information. *
* *
* EmpireMUD based upon CircleMUD 3.0, bpl 17, by Jeremy Elson. *
* CircleMUD (C) 1993, 94 by the Trustees of the Johns Hopkins University *
* CircleMUD is based on DikuMUD, Copyright (C) 1990, 1991. *
************************************************************************ */
#include "conf.h"
#include "sysdep.h"
#include "structs.h"
#include "utils.h"
#include "interpreter.h"
#include "db.h"
#include "comm.h"
#include "olc.h"
#include "skills.h"
#include "handler.h"
/**
* Contents:
* Helpers
* Utilities
* Database
* OLC Handlers
* Displays
* Edit Modules
*/
// external consts
extern const char *apply_types[];
extern const char *augment_types[];
extern const struct augment_type_data augment_info[];
extern const char *augment_flags[];
extern const char *wear_bits[];
// external funcs
extern struct resource_data *copy_resource_list(struct resource_data *input);
void get_resource_display(struct resource_data *list, char *save_buffer);
//////////////////////////////////////////////////////////////////////////////
//// HELPERS /////////////////////////////////////////////////////////////////
/**
* Used for choosing an augment that's valid for the player.
*
* @param char_data *ch The person trying to augment.
* @param char *name The argument.
* @param int type AUGMENT_x type.
* @return augment_data* The matching augment, or NULL if none.
*/
augment_data *find_augment_by_name(char_data *ch, char *name, int type) {
augment_data *aug, *next_aug, *partial = NULL;
HASH_ITER(sorted_hh, sorted_augments, aug, next_aug) {
if (GET_AUG_TYPE(aug) != type) {
continue;
}
if (AUGMENT_FLAGGED(aug, AUG_IN_DEVELOPMENT) && !IS_IMMORTAL(ch)) {
continue;
}
if (GET_AUG_ABILITY(aug) != NO_ABIL && !has_ability(ch, GET_AUG_ABILITY(aug))) {
continue;
}
if (GET_AUG_REQUIRES_OBJ(aug) != NOTHING && !get_obj_in_list_vnum(GET_AUG_REQUIRES_OBJ(aug), ch->carrying)) {
continue;
}
// matches:
if (!str_cmp(name, GET_AUG_NAME(aug))) {
// perfect match
return aug;
}
if (!partial && is_multiword_abbrev(name, GET_AUG_NAME(aug))) {
// probable match
partial = aug;
}
}
// no exact match...
return partial;
}
/**
* Checks targeting flags on augments.
*
* @param char_data *ch The person who will get any error messages.
* @param obj_data *obj The item to validate.
* @param augment_data *aug The augment we're trying to apply.
* @param bool send_messages If TRUE, sends the error message to ch.
* @return bool TRUE if successful, FALSE if an error was sent.
*/
bool validate_augment_target(char_data *ch, obj_data *obj, augment_data *aug, bool send_messages) {
char buf[MAX_STRING_LENGTH], part[MAX_STRING_LENGTH];
bitvector_t partial_wear, flags;
int iter;
flags = GET_AUG_FLAGS(aug) | augment_info[GET_AUG_TYPE(aug)].default_flags;
// wear-based targeting
partial_wear = GET_AUG_WEAR_FLAGS(aug) & ~ITEM_WEAR_TAKE;
if (partial_wear != NOBITS && !CAN_WEAR(obj, partial_wear)) {
if (send_messages) {
prettier_sprintbit(partial_wear, wear_bits, part);
snprintf(buf, sizeof(buf), "You can only use that %s on items that are worn on: %s.\r\n", augment_info[GET_AUG_TYPE(aug)].noun, part);
for (iter = 1; iter < strlen(buf); ++iter) {
buf[iter] = LOWER(buf[iter]); // lowercase both parts of the string
}
send_to_char(buf, ch);
}
return FALSE;
}
if (IS_SET(flags, AUG_ARMOR) && !IS_ARMOR(obj)) {
if (send_messages) {
msg_to_char(ch, "You can only put that %s on armor.\r\n", augment_info[GET_AUG_TYPE(aug)].noun);
}
return FALSE;
}
if (IS_SET(flags, AUG_SHIELD) && !IS_SHIELD(obj)) {
if (send_messages) {
msg_to_char(ch, "You can only put that %s on a shield.\r\n", augment_info[GET_AUG_TYPE(aug)].noun);
}
return FALSE;
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////
//// UTILITIES ///////////////////////////////////////////////////////////////
/**
* Checks for common augment problems and reports them to ch.
*
* @param augment_data *aug The item to audit.
* @param char_data *ch The person to report to.
* @return bool TRUE if any problems were reported; FALSE if all good.
*/
bool audit_augment(augment_data *aug, char_data *ch) {
char temp[MAX_STRING_LENGTH];
struct apply_data *app;
bool problem = FALSE;
if (AUGMENT_FLAGGED(aug, AUG_IN_DEVELOPMENT)) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "IN-DEVELOPMENT");
problem = TRUE;
}
if (GET_AUG_TYPE(aug) == AUGMENT_NONE) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "Type not set");
problem = TRUE;
}
if (!GET_AUG_NAME(aug) || !*GET_AUG_NAME(aug) || !str_cmp(GET_AUG_NAME(aug), "unnamed augment")) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "No name set");
problem = TRUE;
}
strcpy(temp, GET_AUG_NAME(aug));
strtolower(temp);
if (strcmp(GET_AUG_NAME(aug), temp)) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "Non-lowercase name");
problem = TRUE;
}
for (app = GET_AUG_APPLIES(aug); app; app = app->next) {
if (app->location == APPLY_NONE || app->weight == 0) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "Invalid apply: %d to %s", app->weight, apply_types[app->location]);
problem = TRUE;
}
}
if (GET_AUG_ABILITY(aug) == NO_ABIL && GET_AUG_REQUIRES_OBJ(aug) == NOTHING) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "Requires no ability or object");
problem = TRUE;
}
if (GET_AUG_REQUIRES_OBJ(aug) != NOTHING && !obj_proto(GET_AUG_REQUIRES_OBJ(aug))) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "Requires-object does not exist");
problem = TRUE;
}
if (!GET_AUG_RESOURCES(aug)) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "No resources required");
problem = TRUE;
}
// AUG_x: any new targeting flags must be added here
if (GET_AUG_WEAR_FLAGS(aug) == NOBITS && !AUGMENT_FLAGGED(aug, AUG_ARMOR | AUG_SHIELD)) {
olc_audit_msg(ch, GET_AUG_VNUM(aug), "No targeting flags");
problem = TRUE;
}
return problem;
}
/**
* For the .list command.
*
* @param augment_data *aug The thing to list.
* @param bool detail If TRUE, provide additional details
* @return char* The line to show (without a CRLF).
*/
char *list_one_augment(augment_data *aug, bool detail) {
static char output[MAX_STRING_LENGTH];
char part[MAX_STRING_LENGTH], applies[MAX_STRING_LENGTH];
struct apply_data *app;
ability_data *abil;
if (detail) {
// ability required
if (GET_AUG_ABILITY(aug) == NO_ABIL) {
*part = '\0';
}
else {
sprintf(part, " (%s", get_ability_name_by_vnum(GET_AUG_ABILITY(aug)));
if ((abil = find_ability_by_vnum(GET_AUG_ABILITY(aug))) && ABIL_ASSIGNED_SKILL(abil) != NULL) {
sprintf(part + strlen(part), " - %s %d", SKILL_ABBREV(ABIL_ASSIGNED_SKILL(abil)), ABIL_SKILL_LEVEL(abil));
}
strcat(part, ")");
}
// applies
*applies = '\0';
for (app = GET_AUG_APPLIES(aug); app; app = app->next) {
sprintf(applies + strlen(applies), "%s%d to %s", (app == GET_AUG_APPLIES(aug)) ? " " : ", ", app->weight, apply_types[app->location]);
}
snprintf(output, sizeof(output), "[%5d] %s%s%s", GET_AUG_VNUM(aug), GET_AUG_NAME(aug), part, applies);
}
else {
snprintf(output, sizeof(output), "[%5d] %s", GET_AUG_VNUM(aug), GET_AUG_NAME(aug));
}
return output;
}
/**
* Searches for all uses of an augment and displays them.
*
* @param char_data *ch The player.
* @param any_vnum vnum The augment vnum.
*/
void olc_search_augment(char_data *ch, any_vnum vnum) {
char buf[MAX_STRING_LENGTH];
augment_data *aug = augment_proto(vnum);
int size, found;
if (!aug) {
msg_to_char(ch, "There is no augment %d.\r\n", vnum);
return;
}
found = 0;
size = snprintf(buf, sizeof(buf), "Occurrences of augment %d (%s):\r\n", vnum, GET_AUG_NAME(aug));
// augments are not actually used anywhere else
if (found > 0) {
size += snprintf(buf + size, sizeof(buf) - size, "%d location%s shown\r\n", found, PLURAL(found));
}
else {
size += snprintf(buf + size, sizeof(buf) - size, " none\r\n");
}
page_string(ch->desc, buf, TRUE);
}
// Simple vnum sorter for the augment hash
int sort_augments(augment_data *a, augment_data *b) {
return GET_AUG_VNUM(a) - GET_AUG_VNUM(b);
}
// typealphabetic sorter for sorted_augments
int sort_augments_by_data(augment_data *a, augment_data *b) {
ability_data *a_abil, *b_abil;
int a_level, b_level;
if (GET_AUG_TYPE(a) != GET_AUG_TYPE(b)) {
return GET_AUG_TYPE(a) - GET_AUG_TYPE(b);
}
a_abil = find_ability_by_vnum(GET_AUG_ABILITY(a));
b_abil = find_ability_by_vnum(GET_AUG_ABILITY(b));
a_level = a_abil ? ABIL_SKILL_LEVEL(a_abil) : 0;
b_level = b_abil ? ABIL_SKILL_LEVEL(b_abil) : 0;
// reverse level sort
if (a_level != b_level) {
return b_level - a_level;
}
return strcmp(NULLSAFE(GET_AUG_NAME(a)), NULLSAFE(GET_AUG_NAME(b)));
}
//////////////////////////////////////////////////////////////////////////////
//// DATABASE ////////////////////////////////////////////////////////////////
/**
* Puts an augment into the hash table.
*
* @param augment_data *aug The augment data to add to the table.
*/
void add_augment_to_table(augment_data *aug) {
augment_data *find;
any_vnum vnum;
if (aug) {
vnum = GET_AUG_VNUM(aug);
HASH_FIND_INT(augment_table, &vnum, find);
if (!find) {
HASH_ADD_INT(augment_table, vnum, aug);
HASH_SORT(augment_table, sort_augments);
}
// sorted table
HASH_FIND(sorted_hh, sorted_augments, &vnum, sizeof(int), find);
if (!find) {
HASH_ADD(sorted_hh, sorted_augments, vnum, sizeof(int), aug);
HASH_SRT(sorted_hh, sorted_augments, sort_augments_by_data);
}
}
}
/**
* @param any_vnum vnum Any augment vnum
* @return augment_data* The augment, or NULL if it doesn't exist
*/
augment_data *augment_proto(any_vnum vnum) {
augment_data *aug;
if (vnum < 0 || vnum == NOTHING) {
return NULL;
}
HASH_FIND_INT(augment_table, &vnum, aug);
return aug;
}
/**
* Removes an augment from the hash table.
*
* @param augment_data *aug The augment data to remove from the table.
*/
void remove_augment_from_table(augment_data *aug) {
HASH_DEL(augment_table, aug);
HASH_DELETE(sorted_hh, sorted_augments, aug);
}
/**
* Initializes a new augment. This clears all memory for it, so set the vnum
* AFTER.
*
* @param augment_data *aug The augment to initialize.
*/
void clear_augment(augment_data *aug) {
memset((char *) aug, 0, sizeof(augment_data));
GET_AUG_VNUM(aug) = NOTHING;
GET_AUG_ABILITY(aug) = NO_ABIL;
GET_AUG_REQUIRES_OBJ(aug) = NOTHING;
}
/**
* frees up memory for an augment data item.
*
* See also: olc_delete_augment
*
* @param augment_data *aug The augment data to free.
*/
void free_augment(augment_data *aug) {
augment_data *proto = augment_proto(GET_AUG_VNUM(aug));
if (GET_AUG_NAME(aug) && (!proto || GET_AUG_NAME(aug) != GET_AUG_NAME(proto))) {
free(GET_AUG_NAME(aug));
}
if (GET_AUG_APPLIES(aug) && (!proto || GET_AUG_APPLIES(aug) != GET_AUG_APPLIES(proto))) {
free_apply_list(GET_AUG_APPLIES(aug));
}
if (GET_AUG_RESOURCES(aug) && (!proto || GET_AUG_RESOURCES(aug) != GET_AUG_RESOURCES(proto))) {
free_resource_list(GET_AUG_RESOURCES(aug));
}
free(aug);
}
/**
* Read one augment from file.
*
* @param FILE *fl The open .aug file
* @param any_vnum vnum The augment vnum
*/
void parse_augment(FILE *fl, any_vnum vnum) {
void parse_apply(FILE *fl, struct apply_data **list, char *error_str);
void parse_resource(FILE *fl, struct resource_data **list, char *error_str);
char line[256], error[256], str_in[256], str_in2[256];
augment_data *aug, *find;
int int_in[4];
CREATE(aug, augment_data, 1);
clear_augment(aug);
GET_AUG_VNUM(aug) = vnum;
HASH_FIND_INT(augment_table, &vnum, find);
if (find) {
log("WARNING: Duplicate augment vnum #%d", vnum);
// but have to load it anyway to advance the file
}
add_augment_to_table(aug);
// for error messages
sprintf(error, "augment vnum %d", vnum);
// line 1
GET_AUG_NAME(aug) = fread_string(fl, error);
// line 2: type flags wear-flags ability
if (!get_line(fl, line) || sscanf(line, "%d %s %s %d %d", &int_in[0], str_in, str_in2, &int_in[1], &int_in[2]) != 5) {
log("SYSERR: Format error in line 2 of %s", error);
exit(1);
}
GET_AUG_TYPE(aug) = int_in[0];
GET_AUG_FLAGS(aug) = asciiflag_conv(str_in);
GET_AUG_WEAR_FLAGS(aug) = asciiflag_conv(str_in2);
GET_AUG_ABILITY(aug) = int_in[1];
GET_AUG_REQUIRES_OBJ(aug) = int_in[2];
// optionals
for (;;) {
if (!get_line(fl, line)) {
log("SYSERR: Format error in %s, expecting alphabetic flags", error);
exit(1);
}
switch (*line) {
case 'A': { // applies
parse_apply(fl, &GET_AUG_APPLIES(aug), error);
break;
}
case 'R': { // resources
parse_resource(fl, &GET_AUG_RESOURCES(aug), error);
break;
}
// end
case 'S': {
return;
}
default: {
log("SYSERR: Format error in %s, expecting alphabetic flags", error);
exit(1);
}
}
}
}
// writes entries in the augment index
void write_augments_index(FILE *fl) {
augment_data *aug, *next_aug;
int this, last;
last = -1;
HASH_ITER(hh, augment_table, aug, next_aug) {
// determine "zone number" by vnum
this = (int)(GET_AUG_VNUM(aug) / 100);
if (this != last) {
fprintf(fl, "%d%s\n", this, AUG_SUFFIX);
last = this;
}
}
}
/**
* Outputs one augment item in the db file format, starting with a #VNUM and
* ending with an S.
*
* @param FILE *fl The file to write it to.
* @param augment_data *aug The thing to save.
*/
void write_augment_to_file(FILE *fl, augment_data *aug) {
void write_applies_to_file(FILE *fl, struct apply_data *list);
void write_resources_to_file(FILE *fl, char letter, struct resource_data *list);
char temp[256], temp2[256];
if (!fl || !aug) {
syslog(SYS_ERROR, LVL_START_IMM, TRUE, "SYSERR: write_augment_to_file called without %s", !fl ? "file" : "augment");
return;
}
fprintf(fl, "#%d\n", GET_AUG_VNUM(aug));
// 1. name
fprintf(fl, "%s~\n", NULLSAFE(GET_AUG_NAME(aug)));
// 2. type flags wear-flags ability requires-obj
strcpy(temp, bitv_to_alpha(GET_AUG_FLAGS(aug)));
strcpy(temp2, bitv_to_alpha(GET_AUG_WEAR_FLAGS(aug)));
fprintf(fl, "%d %s %s %d %d\n", GET_AUG_TYPE(aug), temp, temp2, GET_AUG_ABILITY(aug), GET_AUG_REQUIRES_OBJ(aug));
// 'A': applies
write_applies_to_file(fl, GET_AUG_APPLIES(aug));
// 'R': resources
write_resources_to_file(fl, 'R', GET_AUG_RESOURCES(aug));
// end
fprintf(fl, "S\n");
}
//////////////////////////////////////////////////////////////////////////////
//// OLC HANDLERS ////////////////////////////////////////////////////////////
/**
* Creates a new augment entry.
*
* @param any_vnum vnum The number to create.
* @return augment_data* The new augment's prototype.
*/
augment_data *create_augment_table_entry(any_vnum vnum) {
augment_data *aug;
// sanity
if (augment_proto(vnum)) {
log("SYSERR: Attempting to insert augment at existing vnum %d", vnum);
return augment_proto(vnum);
}
CREATE(aug, augment_data, 1);
clear_augment(aug);
GET_AUG_VNUM(aug) = vnum;
GET_AUG_NAME(aug) = str_dup("unnamed augment");
add_augment_to_table(aug);
// save index and augment file now
save_index(DB_BOOT_AUG);
save_library_file_for_vnum(DB_BOOT_AUG, vnum);
return aug;
}
/**
* WARNING: This function actually deletes an augment.
*
* @param char_data *ch The person doing the deleting.
* @param any_vnum vnum The vnum to delete.
*/
void olc_delete_augment(char_data *ch, any_vnum vnum) {
augment_data *aug;
if (!(aug = augment_proto(vnum))) {
msg_to_char(ch, "There is no such augment %d.\r\n", vnum);
return;
}
// remove it from the hash table first
remove_augment_from_table(aug);
// save index and augment file now
save_index(DB_BOOT_AUG);
save_library_file_for_vnum(DB_BOOT_AUG, vnum);
syslog(SYS_OLC, GET_INVIS_LEV(ch), TRUE, "OLC: %s has deleted augment %d", GET_NAME(ch), vnum);
msg_to_char(ch, "Augment %d deleted.\r\n", vnum);
free_augment(aug);
}
/**
* Function to save a player's changes to an augment (or a new one).
*
* @param descriptor_data *desc The descriptor who is saving.
*/
void save_olc_augment(descriptor_data *desc) {
augment_data *proto, *aug = GET_OLC_AUGMENT(desc);
any_vnum vnum = GET_OLC_VNUM(desc);
UT_hash_handle hh, sorted;
// have a place to save it?
if (!(proto = augment_proto(vnum))) {
proto = create_augment_table_entry(vnum);
}
// free prototype strings and pointers
if (GET_AUG_NAME(proto)) {
free(GET_AUG_NAME(proto));
}
free_apply_list(GET_AUG_APPLIES(proto));
free_resource_list(GET_AUG_RESOURCES(proto));
// sanity
if (!GET_AUG_NAME(aug) || !*GET_AUG_NAME(aug)) {
if (GET_AUG_NAME(aug)) {
free(GET_AUG_NAME(aug));
}
GET_AUG_NAME(aug) = str_dup("unnamed augment");
}
// save data back over the proto-type
hh = proto->hh; // save old hash handle
sorted = proto->sorted_hh;
*proto = *aug; // copy over all data
proto->vnum = vnum; // ensure correct vnum
proto->hh = hh; // restore old hash handle
proto->sorted_hh = sorted;
// and save to file
save_library_file_for_vnum(DB_BOOT_AUG, vnum);
// ... and re-sort
HASH_SRT(sorted_hh, sorted_augments, sort_augments_by_data);
}
/**
* Creates a copy of an augment, or clears a new one, for editing.
*
* @param augment_data *input The augment to copy, or NULL to make a new one.
* @return augment_data* The copied augment.
*/
augment_data *setup_olc_augment(augment_data *input) {
extern struct apply_data *copy_apply_list(struct apply_data *input);
augment_data *new;
CREATE(new, augment_data, 1);
clear_augment(new);
if (input) {
// copy normal data
*new = *input;
// copy things that are pointers
GET_AUG_NAME(new) = GET_AUG_NAME(input) ? str_dup(GET_AUG_NAME(input)) : NULL;
// copy lists
GET_AUG_APPLIES(new) = copy_apply_list(GET_AUG_APPLIES(input));
GET_AUG_RESOURCES(new) = copy_resource_list(GET_AUG_RESOURCES(input));
}
else {
// brand new: some defaults
GET_AUG_NAME(new) = str_dup("unnamed augment");
GET_AUG_FLAGS(new) = AUG_IN_DEVELOPMENT;
}
// done
return new;
}
//////////////////////////////////////////////////////////////////////////////
//// DISPLAYS ////////////////////////////////////////////////////////////////
/**
* For vstat.
*
* @param char_data *ch The player requesting stats.
* @param augment_data *aug The augment to display.
*/
void do_stat_augment(char_data *ch, augment_data *aug) {
char buf[MAX_STRING_LENGTH], part[MAX_STRING_LENGTH];
struct apply_data *app;
ability_data *abil;
size_t size;
int num;
if (!aug) {
return;
}
// first line
size = snprintf(buf, sizeof(buf), "VNum: [\tc%d\t0], Name: \tc%s\t0\r\n", GET_AUG_VNUM(aug), GET_AUG_NAME(aug));
snprintf(part, sizeof(part), "%s", (GET_AUG_ABILITY(aug) == NO_ABIL ? "none" : get_ability_name_by_vnum(GET_AUG_ABILITY(aug))));
if ((abil = find_ability_by_vnum(GET_AUG_ABILITY(aug))) && ABIL_ASSIGNED_SKILL(abil) != NULL) {
snprintf(part + strlen(part), sizeof(part) - strlen(part), " (%s %d)", SKILL_ABBREV(ABIL_ASSIGNED_SKILL(abil)), ABIL_SKILL_LEVEL(abil));
}
size += snprintf(buf + size, sizeof(buf) - size, "Type: [\ty%s\t0], Requires Ability: [\ty%s\t0]\r\n", augment_types[GET_AUG_TYPE(aug)], part);
if (GET_AUG_REQUIRES_OBJ(aug) != NOTHING) {
size += snprintf(buf + size, sizeof(buf) - size, "Requires item: [%d] \tg%s\t0\r\n", GET_AUG_REQUIRES_OBJ(aug), skip_filler(get_obj_name_by_proto(GET_AUG_REQUIRES_OBJ(aug))));
}
sprintbit(GET_AUG_FLAGS(aug), augment_flags, part, TRUE);
size += snprintf(buf + size, sizeof(buf) - size, "Flags: \tg%s\t0\r\n", part);
sprintbit(GET_AUG_WEAR_FLAGS(aug), wear_bits, part, TRUE);
size += snprintf(buf + size, sizeof(buf) - size, "Targets wear location: \ty%s\t0\r\n", part);
// applies
size += snprintf(buf + size, sizeof(buf) - size, "Applies: ");
for (app = GET_AUG_APPLIES(aug), num = 0; app; app = app->next, ++num) {
size += snprintf(buf + size, sizeof(buf) - size, "%s%d to %s", num ? ", " : "", app->weight, apply_types[app->location]);
}
if (!GET_AUG_APPLIES(aug)) {
size += snprintf(buf + size, sizeof(buf) - size, "none");
}
size += snprintf(buf + size, sizeof(buf) - size, "\r\n");
// resources
get_resource_display(GET_AUG_RESOURCES(aug), part);
size += snprintf(buf + size, sizeof(buf) - size, "Resource cost:\r\n%s", part);
page_string(ch->desc, buf, TRUE);
}
/**
* This is the main recipe display for augment OLC. It displays the user's
* currently-edited augment.
*
* @param char_data *ch The person who is editing an augment and will see its display.
*/
void olc_show_augment(char_data *ch) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
char buf[MAX_STRING_LENGTH], lbuf[MAX_STRING_LENGTH];
struct apply_data *app;
ability_data *abil;
int num;
if (!aug) {
return;
}
*buf = '\0';
sprintf(buf + strlen(buf), "[\tc%d\t0] \tc%s\t0\r\n", GET_OLC_VNUM(ch->desc), !augment_proto(GET_AUG_VNUM(aug)) ? "new augment" : GET_AUG_NAME(augment_proto(GET_AUG_VNUM(aug))));
sprintf(buf + strlen(buf), "<\tyname\t0> %s\r\n", NULLSAFE(GET_AUG_NAME(aug)));
sprintf(buf + strlen(buf), "<\tytype\t0> %s\r\n", augment_types[GET_AUG_TYPE(aug)]);
sprintbit(GET_AUG_FLAGS(aug), augment_flags, lbuf, TRUE);
sprintf(buf + strlen(buf), "<\tyflags\t0> %s\r\n", lbuf);
sprintbit(GET_AUG_WEAR_FLAGS(aug), wear_bits, lbuf, TRUE);
sprintf(buf + strlen(buf), "<\tywear\t0> %s\r\n", lbuf);
// ability required
if (GET_AUG_ABILITY(aug) == NO_ABIL || !(abil = find_ability_by_vnum(GET_AUG_ABILITY(aug)))) {
strcpy(buf1, "none");
}
else {
sprintf(buf1, "%s", ABIL_NAME(abil));
if (ABIL_ASSIGNED_SKILL(abil)) {
sprintf(buf1 + strlen(buf1), " (%s %d)", SKILL_NAME(ABIL_ASSIGNED_SKILL(abil)), ABIL_SKILL_LEVEL(abil));
}
}
sprintf(buf + strlen(buf), "<\tyrequiresability\t0> %s\r\n", buf1);
sprintf(buf + strlen(buf), "<\tyrequiresobject\t0> %d - %s\r\n", GET_AUG_REQUIRES_OBJ(aug), GET_AUG_REQUIRES_OBJ(aug) == NOTHING ? "none" : get_obj_name_by_proto(GET_AUG_REQUIRES_OBJ(aug)));
// applies
sprintf(buf + strlen(buf), "Attribute applies: <\tyapply\t0>\r\n");
for (app = GET_AUG_APPLIES(aug), num = 1; app; app = app->next, ++num) {
sprintf(buf + strlen(buf), " %2d. %d to %s\r\n", num, app->weight, apply_types[app->location]);
}
// resources
sprintf(buf + strlen(buf), "Resources required: <\tyresource\t0>\r\n");
if (GET_AUG_RESOURCES(aug)) {
get_resource_display(GET_AUG_RESOURCES(aug), lbuf);
strcat(buf, lbuf);
}
page_string(ch->desc, buf, TRUE);
}
/**
* Searches the augment db for a match, and prints it to the character.
*
* @param char *searchname The search string.
* @param char_data *ch The player who is searching.
* @return int The number of matches shown.
*/
int vnum_augment(char *searchname, char_data *ch) {
augment_data *iter, *next_iter;
int found = 0;
HASH_ITER(hh, augment_table, iter, next_iter) {
if (multi_isname(searchname, GET_AUG_NAME(iter))) {
msg_to_char(ch, "%3d. [%5d] %s (%s)\r\n", ++found, GET_AUG_VNUM(iter), GET_AUG_NAME(iter), augment_types[GET_AUG_TYPE(iter)]);
}
}
return found;
}
//////////////////////////////////////////////////////////////////////////////
//// OLC MODULES /////////////////////////////////////////////////////////////
OLC_MODULE(augedit_ability) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
ability_data *abil;
if (!*argument) {
msg_to_char(ch, "Require what ability (or 'none')?\r\n");
}
else if (!str_cmp(argument, "none")) {
GET_AUG_ABILITY(aug) = NO_ABIL;
if (PRF_FLAGGED(ch, PRF_NOREPEAT)) {
send_config_msg(ch, "ok_string");
}
else {
msg_to_char(ch, "It will require no ability.\r\n");
}
}
else if (!(abil = find_ability(argument))) {
msg_to_char(ch, "Invalid ability '%s'.\r\n", argument);
}
else {
GET_AUG_ABILITY(aug) = ABIL_VNUM(abil);
if (PRF_FLAGGED(ch, PRF_NOREPEAT)) {
send_config_msg(ch, "ok_string");
}
else {
msg_to_char(ch, "It now requires the %s ability.\r\n", ABIL_NAME(abil));
}
}
}
OLC_MODULE(augedit_apply) {
void olc_process_applies(char_data *ch, char *argument, struct apply_data **list);
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
olc_process_applies(ch, argument, &GET_AUG_APPLIES(aug));
}
OLC_MODULE(augedit_flags) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
bool had_indev = IS_SET(GET_AUG_FLAGS(aug), AUG_IN_DEVELOPMENT) ? TRUE : FALSE;
GET_AUG_FLAGS(aug) = olc_process_flag(ch, argument, "augment", "flags", augment_flags, GET_AUG_FLAGS(aug));
// validate removal of IN-DEVELOPMENT
if (had_indev && !IS_SET(GET_AUG_FLAGS(aug), AUG_IN_DEVELOPMENT) && GET_ACCESS_LEVEL(ch) < LVL_UNRESTRICTED_BUILDER && !OLC_FLAGGED(ch, OLC_FLAG_CLEAR_IN_DEV)) {
msg_to_char(ch, "You don't have permission to remove the IN-DEVELOPMENT flag.\r\n");
SET_BIT(GET_AUG_FLAGS(aug), AUG_IN_DEVELOPMENT);
}
}
OLC_MODULE(augedit_name) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
olc_process_string(ch, argument, "name", &GET_AUG_NAME(aug));
}
OLC_MODULE(augedit_requiresobject) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
obj_vnum old = GET_AUG_REQUIRES_OBJ(aug);
if (!str_cmp(argument, "none") || atoi(argument) == NOTHING) {
GET_AUG_REQUIRES_OBJ(aug) = NOTHING;
if (PRF_FLAGGED(ch, PRF_NOREPEAT)) {
send_config_msg(ch, "ok_string");
}
else {
msg_to_char(ch, "It no longer requires an object to see it in the %s list.\r\n", augment_types[GET_AUG_TYPE(aug)]);
}
}
else {
GET_AUG_REQUIRES_OBJ(aug) = olc_process_number(ch, argument, "object vnum", "requiresobject", 0, MAX_VNUM, GET_AUG_REQUIRES_OBJ(aug));
if (!obj_proto(GET_AUG_REQUIRES_OBJ(aug))) {
GET_AUG_REQUIRES_OBJ(aug) = old;
msg_to_char(ch, "There is no object with that vnum. Old value restored.\r\n");
}
else if (!PRF_FLAGGED(ch, PRF_NOREPEAT)) {
msg_to_char(ch, "It now requires %s.\r\n", get_obj_name_by_proto(GET_AUG_REQUIRES_OBJ(aug)));
}
}
}
OLC_MODULE(augedit_resource) {
void olc_process_resources(char_data *ch, char *argument, struct resource_data **list);
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
olc_process_resources(ch, argument, &GET_AUG_RESOURCES(aug));
}
OLC_MODULE(augedit_type) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
GET_AUG_TYPE(aug) = olc_process_type(ch, argument, "type", "type", augment_types, GET_AUG_TYPE(aug));
}
OLC_MODULE(augedit_wear) {
augment_data *aug = GET_OLC_AUGMENT(ch->desc);
GET_AUG_WEAR_FLAGS(aug) = olc_process_flag(ch, argument, "wear", "wear", wear_bits, GET_AUG_WEAR_FLAGS(aug));
}
|
580625.c | #include <stdlib.h>
#include <stdio.h>
#include "Item.h"
#include "QUEUE.h"
static Item *q;
static Item *r;
static int N;
static int c;
void QUEUEinit(int maxN) {
int i;
q = malloc(maxN * sizeof(Item));
r = malloc(maxN * sizeof(int));
N = maxN;
c = 0;
for (i = 0; i < N; ++i) {
r[i] = 0;
}
}
int QUEUEempty(void) {
return c;
}
void QUEUEput(Item item) {
int t;
for (t = 0; t < N; ++t) {
if (q[t] == item) {
r[t] = 0;
}
}
for (t = rand() % N; r[t] > 0; t = (t + 1) % N)
;
q[t] = item;
r[t] = 1;
++c;
}
Item QUEUEget(void) {
int t;
for (t = rand() % N; r[t] == 0; t = (t + 1) % N)
;
r[t] = 0;
--c;
return q[t];
}
|
401954.c | #include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
// Max function
#define max(a,b) \
({ __typeof__ (a) _a = (a); \
__typeof__ (b) _b = (b); \
_a > _b ? _a : _b; })
// Binary Tree Node Structure
typedef struct node {
struct node *left;
struct node *right;
int data;
}Node;
// Function Prototypes
Node* createBinaryTree(int *values, int size);
Node* createNode(int data);
bool searchBinaryTree(int data, Node *root);
Node* insertIntoBinaryTree(int data, Node *root);
void preorder(Node *root);
void inorder(Node *root);
void postorder(Node *root);
void createVine(Node **root);
void printVine(Node *root);
Node* deleteInorderPredecessor(Node *root);
int numberOfNodes(Node *root);
Node* DSW(Node **root);
Node* rotateLeft(Node *root);
Node* rotateRight(Node *root);
int diameter(Node *root);
int maxHeight(Node *root);
// Function definitions
Node* createNode(int data) {
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->left = NULL;
newNode->right = NULL;
newNode->data = data;
return newNode;
}
Node* createBinaryTree(int *values, int size) {
if (size <= 0) {
printf("No values in the input!\n");
}
Node *root = createNode(values[0]);
// printf("Inserting %d \n", values[0]);
for (int i = 1; i < size; ++i) {
// printf("Inserting %d ", values[i]);
insertIntoBinaryTree(values[i],root);
// printf("Done!!\n");
}
printf("Done Creating Tree!\n");
printf("\n");
return root;
}
Node* insertIntoBinaryTree(int data, Node *root) {
if (root == NULL) {
return createNode(data);
}
if (data < root->data) {
root->left = insertIntoBinaryTree(data, root->left);
}
else {
root->right = insertIntoBinaryTree(data, root->right);
}
return root;
}
void preorder(Node *root) {
if (root == NULL) {
return;
}
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
void inorder(Node *root) {
if (root == NULL) {
return;
}
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
void postorder(Node *root) {
if (root == NULL) {
return;
}
postorder(root->left);
postorder(root->right);
printf("%d ", root->data);
}
bool searchBinaryTree(int data, Node *root) {
if (root == NULL ) {
return false;
}
if (data < root->data) {
return searchBinaryTree(data, root->left);
}
else if (data > root->data) {
return searchBinaryTree(data, root->right);
}
return true;
}
Node* deleteInorderPredecessor(Node *root) {
if (!root) {return NULL;}
Node *temp = root;
root = root->left;
if (!root) {return temp;}
if (root->right) {
temp = root;
root = root->right;
}
else {
temp->left = root->left;
return root;
}
while(root->right) {
root = root->right;
temp = temp->right;
}
temp->right = root->left;
return root;
}
void createVine(Node **root) {
if ((*root) == NULL) {
return;
}
while ((*root)->left) {
// printf("Next one on the left of %d is %d \n", (*root)->data,(*root)->left->data);
Node *temp = *root;
Node *pre = deleteInorderPredecessor(temp);
// printf("Preorder predecessor is %d\n", pre->data);
pre->right = *root;
pre->left = (*root)->left;
(*root)->left = NULL;
*root = pre;
}
if ((*root)->right == NULL) {return;}
// printf("Next one to be stripped of left children is %d \n",(*root)->right->data);
createVine(&((*root)->right));
}
void printVine(Node *root) {
while(root) {
printf("%d ", root->data);
root = root->right;
}
printf("\n");
}
int numberOfNodes(Node *root) {
if (root == NULL) {
return 0;
}
return 1 + numberOfNodes(root->left) + numberOfNodes(root->right);
}
Node* rotateLeft(Node *root) {
if (root == NULL || root->right == NULL) {
return root;
}
Node *nodeToRotate = root->right;
root->right = nodeToRotate->left;
nodeToRotate->left = root;
return nodeToRotate;
}
Node* rotateRight(Node *root) {
if (root == NULL) {
return root;
}
exit(0);
}
Node* DSW(Node **root) {
// Create backbone tree
if (*root == NULL) {
return *root;
}
createVine(root);
printVine(*root);
int n = numberOfNodes(*root);
int m = pow(2, floor(log2(n+1))) - 1;
printf("There are %d in the closest perfect tree form but we have %d nodes here!\n", m,n);
if (n > m) {
// Perform n-m rotations from the top (Pre-processing)
for (int i=0;i<(n-m);i++) {
*root = rotateLeft(*root);
}
}
// Perform a rotation for every alternate node
while (m > 1) {
Node *temp = *root;
Node *parent = NULL;
*root = temp->right;
printf("Root is now %d\n",(*root)->data );
m = m/2;
printf("M is now %d\n", m);
printVine(temp);
while (temp && temp->right && (temp->right->right || temp->right->left)) {
printf("Rotating about node %d \n", temp->data);
printVine(*root);
printf("--------------\n");
if (parent) {
parent->right = temp->right;
}
temp = rotateLeft(temp);
parent = temp;
temp = temp->right;
}
}
return *root;
}
int maxHeight(Node *root) {
if (!root) {
return 0;
}
int leftHeight = maxHeight(root->left);
int rightHeight = maxHeight(root->right);
if (leftHeight > rightHeight) {
return leftHeight + 1;
}
else {
return rightHeight + 1;
}
}
int diameter(Node *root) {
if (!root) {
return 0;
}
int leftSubtreeHeight = maxHeight(root->left);
int rightSubtreeHeight = maxHeight(root->right);
int leftSubtreeDiameter = diameter(root->left);
int rightSubtreeDiameter = diameter(root->right);
return max(max(leftSubtreeDiameter, rightSubtreeDiameter), leftSubtreeHeight + rightSubtreeHeight + 1);
}
// Main
// int main(void) {
// // int data[] = {50,30,100,10,40, 110,75};
// int data[] = {100, 200, 50, 20, 60, 10, 15, 55, 65, 70, 80};
// int size = sizeof(data)/sizeof(data[0]);
// printf("Hi there! i have %d elements\n", size);
// Node *root = createBinaryTree(data, size);
// inorder(root);
// printf("\n");
// printf("Max height is %d \n", maxHeight(root));
// printf("Diameter is %d\n", diameter(root));
// return 0;
// } |
100281.c | /*
* Copyright (c) 2014-2015, University of Lugano
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the copyright holders nor the names of it
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <evpaxos.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
struct client_value
{
struct timeval t;
size_t size;
char value[];
};
static int verbose = 0;
static void
handle_sigint(int sig, short ev, void* arg)
{
struct event_base* base = arg;
printf("Caught signal %d\n", sig);
event_base_loopexit(base, NULL);
}
static void
deliver(unsigned iid, char* value, size_t size, void* arg)
{
struct client_value* val = (struct client_value*)value;
printf("%ld.%06d [%.16s] %ld bytes\n", val->t.tv_sec, val->t.tv_usec,
val->value, (long)val->size);
}
static void
start_replica(int id, const char* config)
{
struct event* sig;
struct event_base* base;
struct evpaxos_replica* replica;
deliver_function cb = NULL;
if (verbose)
cb = deliver;
base = event_base_new();
replica = evpaxos_replica_init(id, config, cb, NULL, base);
if (replica == NULL) {
printf("Could not start the replica!\n");
exit(1);
}
sig = evsignal_new(base, SIGINT, handle_sigint, base);
evsignal_add(sig, NULL);
signal(SIGPIPE, SIG_IGN);
event_base_dispatch(base);
event_free(sig);
evpaxos_replica_free(replica);
event_base_free(base);
}
static void
usage(const char* prog)
{
printf("Usage: %s id [path/to/paxos.conf] [-h] [-s]\n", prog);
printf(" %-30s%s\n", "-h, --help", "Output this message and exit");
printf(" %-30s%s\n", "-v, --verbose", "Print delivered messages");
exit(1);
}
int
main(int argc, char const *argv[])
{
int id;
int i = 2;
const char* config = "../paxos.conf";
if (argc < 2)
usage(argv[0]);
id = atoi(argv[1]);
if (argc >= 3 && argv[2][0] != '-') {
config = argv[2];
i++;
}
while (i != argc) {
if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
usage(argv[0]);
else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0)
verbose = 1;
else
usage(argv[0]);
i++;
}
start_replica(id, config);
return 0;
}
|
489650.c | /* crypto/x509/x509type.c */
/* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "cryptlib.h"
#include <openssl/evp.h>
#include <openssl/objects.h>
#include <openssl/x509.h>
int X509_certificate_type(X509 *x, EVP_PKEY *pkey)
{
EVP_PKEY *pk;
int ret=0,i;
if (x == NULL) return(0);
if (pkey == NULL)
pk=X509_get_pubkey(x);
else
pk=pkey;
if (pk == NULL) return(0);
switch (pk->type)
{
case EVP_PKEY_RSA:
ret=EVP_PK_RSA|EVP_PKT_SIGN;
/* if (!sign only extension) */
ret|=EVP_PKT_ENC;
break;
case EVP_PKEY_DSA:
ret=EVP_PK_DSA|EVP_PKT_SIGN;
break;
case EVP_PKEY_EC:
ret=EVP_PK_EC|EVP_PKT_SIGN|EVP_PKT_EXCH;
break;
case EVP_PKEY_DH:
ret=EVP_PK_DH|EVP_PKT_EXCH;
break;
default:
break;
}
i=X509_get_signature_type(x);
switch (i)
{
case EVP_PKEY_RSA:
ret|=EVP_PKS_RSA;
break;
case EVP_PKEY_DSA:
ret|=EVP_PKS_DSA;
break;
case EVP_PKEY_EC:
ret|=EVP_PKS_EC;
break;
default:
break;
}
if (EVP_PKEY_size(pk) <= 1024/8)/* /8 because it's 1024 bits we look
for, not bytes */
ret|=EVP_PKT_EXP;
if(pkey==NULL) EVP_PKEY_free(pk);
return(ret);
}
|
329919.c | /*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* [email protected]
*/
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include "dynamic_memory_check.h"
#include "assertions.h"
#include "log.h"
#include "nas_timer.h"
#include "3gpp_requirements_24.301.h"
#include "common_types.h"
#include "common_defs.h"
#include "3gpp_24.008.h"
#include "mme_app_ue_context.h"
#include "emm_proc.h"
#include "emm_data.h"
#include "emm_sap.h"
#include "emm_cause.h"
#include "service303.h"
#include "nas_itti_messaging.h"
#include "conversions.h"
#include "EmmCommon.h"
#include "3gpp_23.003.h"
#include "3gpp_24.301.h"
#include "3gpp_36.401.h"
#include "AdditionalUpdateType.h"
#include "EpsUpdateResult.h"
#include "EpsUpdateType.h"
#include "MobileStationClassmark2.h"
#include "TrackingAreaIdentityList.h"
#include "common_ies.h"
#include "emm_asDef.h"
#include "emm_regDef.h"
#include "esm_data.h"
#include "mme_api.h"
#include "mme_app_desc.h"
#include "nas_messages_types.h"
#include "nas_procedures.h"
/****************************************************************************/
/**************** E X T E R N A L D E F I N I T I O N S ****************/
/****************************************************************************/
/****************************************************************************/
/******************* L O C A L D E F I N I T I O N S *******************/
/****************************************************************************/
/* TODO Commented some function declarations below since these were called from the code that got removed from TAU request
* handling function. Reason this code was removed: This portion of code was incomplete and was related to handling of
* some optional IEs /scenarios that were not relevant for the TAU periodic update handling and might have resulted in
* unexpected behaviour/instability.
* At present support for TAU is limited to handling of periodic TAU request only mandatory IEs .
* Other aspects of TAU are TODOs for future.
*/
static int _emm_tracking_area_update_reject(
const mme_ue_s1ap_id_t ue_id,
const int emm_cause);
static int _emm_tracking_area_update_accept(nas_emm_tau_proc_t *const tau_proc);
static int _emm_tracking_area_update_abort(
struct emm_context_s *emm_context,
struct nas_base_proc_s *base_proc);
static void _emm_tracking_area_update_t3450_handler(void *args);
static nas_emm_tau_proc_t * _emm_proc_create_procedure_tau(
ue_mm_context_t *const ue_mm_context, emm_tau_request_ies_t *const ies);
/****************************************************************************/
/****************** E X P O R T E D F U N C T I O N S ******************/
/****************************************************************************/
int emm_proc_tracking_area_update_accept(nas_emm_tau_proc_t *const tau_proc)
{
int rc = RETURNerror;
OAILOG_FUNC_IN(LOG_NAS_EMM);
rc = _emm_tracking_area_update_accept(tau_proc);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
/****************************************************************************
** **
** Name: _csfb_handle_tracking_area_req() **
** **
** Description: **
** **
** Inputs: ue_ctx: UE context **
** emm_tau_request_ies_t: TAU Request received from UE **
** **
** Outputs: Return: RETURNok, RETURNerror **
** **
***************************************************************************/
int _csfb_handle_tracking_area_req(
emm_context_t *ue_ctx,
emm_tau_request_ies_t *ies)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
OAILOG_INFO(LOG_NAS_EMM, "EMM-PROC _csfb_handle_tracking_area_req \n");
ue_mm_context_t * ue_mm_context = NULL;
/*In case we receive periodic TAU, send Location Update to MME only if SGS Association is established*/
if (
(EPS_UPDATE_TYPE_COMBINED_TA_LA_UPDATING ==
ies->eps_update_type.eps_update_type_value) ||
(EPS_UPDATE_TYPE_COMBINED_TA_LA_UPDATING_WITH_IMSI_ATTACH ==
ies->eps_update_type.eps_update_type_value) ||
((EPS_UPDATE_TYPE_PERIODIC_UPDATING ==
ies->eps_update_type.eps_update_type_value) &&
ue_ctx->csfbparams.sgs_loc_updt_status == SUCCESS)) {
//Store TAU update type in emm context
ue_ctx->tau_updt_type = ies->eps_update_type.eps_update_type_value;
//Store active flag
ue_ctx->csfbparams.tau_active_flag = ies->eps_update_type.active_flag;
//Store Additional Update
if ((ies->additional_updatetype != NULL) &&
(SMS_ONLY == *(ies->additional_updatetype))) {
ue_ctx->additional_update_type = SMS_ONLY;
}
//Send Location Update Req to MME
nas_emm_tau_proc_t *tau_proc = get_nas_specific_procedure_tau(ue_ctx);
if (!tau_proc) {
ue_mm_context = PARENT_STRUCT(ue_ctx,
struct ue_mm_context_s, emm_context);
tau_proc = _emm_proc_create_procedure_tau(ue_mm_context, ies);
nas_itti_cs_domain_location_update_req(
tau_proc->ue_id, TRACKING_AREA_UPDATE_REQUEST);
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNok);
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNerror);
}
int emm_proc_tracking_area_update_request(
const mme_ue_s1ap_id_t ue_id,
emm_tau_request_ies_t *ies,
int *emm_cause)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
int rc = RETURNerror;
ue_mm_context_t *ue_mm_context = NULL;
emm_context_t *emm_context = NULL;
*emm_cause = EMM_CAUSE_SUCCESS;
/*
* Get the UE's EMM context if it exists
*/
ue_mm_context =
mme_ue_context_exists_mme_ue_s1ap_id(&mme_app_desc.mme_ue_contexts, ue_id);
if (ue_mm_context) {
emm_context = &ue_mm_context->emm_context;
}
// May be the MME APP module did not find the context, but if we have the GUTI, we may find it
if (!ue_mm_context) {
if (INVALID_M_TMSI != ies->old_guti.m_tmsi) {
ue_mm_context = mme_ue_context_exists_guti(
&mme_app_desc.mme_ue_contexts, &ies->old_guti);
if (ue_mm_context) {
emm_context = &ue_mm_context->emm_context;
free_emm_tau_request_ies(&ies);
unlock_ue_contexts(ue_mm_context);
OAILOG_DEBUG(LOG_NAS_EMM, "EMM-PROC- GUTI Context found\n");
} else {
// NO S10
rc = _emm_tracking_area_update_reject(
ue_id, EMM_CAUSE_IMPLICITLY_DETACHED);
increment_counter(
"tracking_area_update_req",
1,
2,
"result",
"failure",
"cause",
"ue_identify_cannot_be_derived");
free_emm_tau_request_ies(&ies);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC- Tracking Area Update request. TAU_Type=%d, active_flag=%d)\n",
ies->eps_update_type.eps_update_type_value,
ies->eps_update_type.active_flag);
if (IS_EMM_CTXT_PRESENT_SECURITY(emm_context)) {
emm_context->_security.kenb_ul_count = emm_context->_security.ul_count;
if (true == ies->is_initial) {
emm_context->_security.next_hop_chaining_count = 0;
}
}
// Check if it is not periodic update and not combined TAU for CSFB.
/*If we receive combined TAU/TAU with IMSI attach send Location Update Req to MME instead of
* sending TAU accept immediately. After receiving Location Update Accept from MME, send TAU accept
*/
if (
(_esm_data.conf.features & MME_API_CSFB_SMS_SUPPORTED) ||
(_esm_data.conf.features & MME_API_SMS_SUPPORTED)) {
if ((_csfb_handle_tracking_area_req(emm_context, ies)) == RETURNok) {
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNok);
}
}
if (
EPS_UPDATE_TYPE_PERIODIC_UPDATING !=
ies->eps_update_type.eps_update_type_value) {
/*
* MME24.301R10_5.5.3.2.4_6 Normal and periodic tracking area updating procedure accepted by the network UE - EPS update type
* If the EPS update type IE included in the TRACKING AREA UPDATE REQUEST message indicates "periodic updating", and the UE was
* previously successfully attached for EPS and non-EPS services, subject to operator policies the MME should allocate a TAI
* list that does not span more than one location area.
*/
// This IE not implemented
OAILOG_WARNING(
LOG_NAS_EMM,
"EMM-PROC- Sending Tracking Area Update Reject. ue_id=" MME_UE_S1AP_ID_FMT
", cause=%d)\n",
ue_id,
EMM_CAUSE_IE_NOT_IMPLEMENTED);
rc = _emm_tracking_area_update_reject(ue_id, EMM_CAUSE_IE_NOT_IMPLEMENTED);
increment_counter(
"tracking_area_update_req",
1,
2,
"result",
"failure",
"cause",
"normal_tau_not_supported");
free_emm_tau_request_ies(&ies);
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
/*
* Requirements MME24.301R10_5.5.3.2.4_3
*/
if (ies->is_ue_radio_capability_information_update_needed) {
OAILOG_DEBUG(
LOG_NAS_EMM, "UE context exists: %s\n", ue_mm_context ? "yes" : "no");
if (ue_mm_context) {
// Note: this is safe from double-free errors because it sets to NULL
// after freeing, which free treats as a no-op.
bdestroy_wrapper(&ue_mm_context->ue_radio_capability);
}
}
/*
* Store the mobile station classmark2 information recieved in Tracking Area Update request
* This wil be required for SMS and SGS service request procedure
*/
if (ies->mobile_station_classmark2) {
emm_context->_mob_st_clsMark2.revisionlevel =
ies->mobile_station_classmark2->revisionlevel;
emm_context->_mob_st_clsMark2.esind = ies->mobile_station_classmark2->esind;
emm_context->_mob_st_clsMark2.a51 = ies->mobile_station_classmark2->a51;
emm_context->_mob_st_clsMark2.rfpowercapability =
ies->mobile_station_classmark2->rfpowercapability;
emm_context->_mob_st_clsMark2.pscapability =
ies->mobile_station_classmark2->pscapability;
emm_context->_mob_st_clsMark2.ssscreenindicator =
ies->mobile_station_classmark2->ssscreenindicator;
emm_context->_mob_st_clsMark2.smcapability =
ies->mobile_station_classmark2->smcapability;
emm_context->_mob_st_clsMark2.vbs = ies->mobile_station_classmark2->vbs;
emm_context->_mob_st_clsMark2.vgcs = ies->mobile_station_classmark2->vgcs;
emm_context->_mob_st_clsMark2.fc = ies->mobile_station_classmark2->fc;
emm_context->_mob_st_clsMark2.cm3 = ies->mobile_station_classmark2->cm3;
emm_context->_mob_st_clsMark2.lcsvacap =
ies->mobile_station_classmark2->lcsvacap;
emm_context->_mob_st_clsMark2.ucs2 = ies->mobile_station_classmark2->ucs2;
emm_context->_mob_st_clsMark2.solsa = ies->mobile_station_classmark2->solsa;
emm_context->_mob_st_clsMark2.cmsp = ies->mobile_station_classmark2->cmsp;
emm_context->_mob_st_clsMark2.a53 = ies->mobile_station_classmark2->a53;
emm_context->_mob_st_clsMark2.a52 = ies->mobile_station_classmark2->a52;
emm_ctx_set_attribute_present(
emm_context, EMM_CTXT_MEMBER_MOB_STATION_CLSMARK2);
}
/*
* Requirement MME24.301R10_5.5.3.2.4_6
*/
//If CSFB feature is not enabled, send TAU accept
if (
EPS_UPDATE_TYPE_PERIODIC_UPDATING ==
ies->eps_update_type.eps_update_type_value) {
/*
* MME24.301R10_5.5.3.2.4_6 Normal and periodic tracking area updating procedure accepted by the network UE - EPS update type
* If the EPS update type IE included in the TRACKING AREA UPDATE REQUEST message indicates "periodic updating", and the UE was
* previously successfully attached for EPS and non-EPS services, subject to operator policies the MME should allocate a TAI
* list that does not span more than one location area.
*/
OAILOG_DEBUG(
LOG_NAS_EMM,
"EMM-PROC- Sending Tracking Area Update Accept. ue_id=" MME_UE_S1AP_ID_FMT
", active flag=%d)\n",
ue_id,
ies->eps_update_type.active_flag);
// Handle periodic TAU
nas_emm_tau_proc_t *tau_proc = get_nas_specific_procedure_tau(emm_context);
if (!tau_proc) {
tau_proc = _emm_proc_create_procedure_tau(ue_mm_context, ies);
if (tau_proc) {
// Store the received voice domain pref & UE usage setting IE
if (ies->voicedomainpreferenceandueusagesetting) {
memcpy(
&emm_context->volte_params.
voice_domain_preference_and_ue_usage_setting,
ies->voicedomainpreferenceandueusagesetting,
sizeof(voice_domain_preference_and_ue_usage_setting_t));
}
rc = _emm_tracking_area_update_accept(tau_proc);
if (rc != RETURNok) {
OAILOG_ERROR(
LOG_NAS_EMM,
"EMM-PROC- Processing Tracking Area Update Accept failed for "
"ue_id=" MME_UE_S1AP_ID_FMT ")\n",
ue_id);
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNerror);
}
increment_counter(
"tracking_area_update_req", 1, 1, "result", "success");
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
} else {
OAILOG_ERROR(LOG_NAS_EMM, "EMM-PROC- Failed to get EMM specific proc"
"for TAU for ue_id= " MME_UE_S1AP_ID_FMT ")\n",ue_id);
}
}
}
free_emm_tau_request_ies(&ies);
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
/****************************************************************************
** **
** Name: emm_proc_tracking_area_update_reject() **
** **
** Description: **
** **
** Inputs: ue_id: UE lower layer identifier **
** emm_cause: EMM cause code to be reported **
** Others: None **
** **
** Outputs: None **
** Return: RETURNok, RETURNerror **
** Others: _emm_data **
** **
***************************************************************************/
int emm_proc_tracking_area_update_reject(
const mme_ue_s1ap_id_t ue_id,
const int emm_cause)
{
int rc = RETURNerror;
OAILOG_FUNC_IN(LOG_NAS_EMM);
rc = _emm_tracking_area_update_reject(ue_id, emm_cause);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
/****************************************************************************/
/********************* L O C A L F U N C T I O N S *********************/
/****************************************************************************/
/* TODO - Compiled out this function to remove compiler warnings since we don't expect TAU Complete from UE as we dont support implicit
* GUTI re-allocation during TAU procedure.
*/
#if 0
static int _emm_tracking_area_update (void *args)
...
#endif
/*
* --------------------------------------------------------------------------
* Timer handlers
* --------------------------------------------------------------------------
*/
/** \fn void _emm_tau_t3450_handler(void *args);
\brief T3450 timeout handler
On the first expiry of the timer, the network shall retransmit the TRACKING AREA UPDATE ACCEPT
message and shall reset and restart timer T3450. The retransmission is performed four times, i.e. on the fifth
expiry of timer T3450, the tracking area updating procedure is aborted. Both, the old and the new GUTI shall be
considered as valid until the old GUTI can be considered as invalid by the network (see subclause 5.4.1.4).
During this period the network acts as described for case a above.
@param [in]args TAU accept data
*/
//------------------------------------------------------------------------------
static void _emm_tracking_area_update_t3450_handler(void *args)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
emm_context_t *emm_context = (emm_context_t *) (args);
if (!(emm_context)) {
OAILOG_ERROR(LOG_NAS_EMM, "T3450 timer expired No EMM context\n");
OAILOG_FUNC_OUT(LOG_NAS_EMM);
}
nas_emm_tau_proc_t *tau_proc = get_nas_specific_procedure_tau(emm_context);
if (tau_proc) {
// Requirement MME24.301R10_5.5.3.2.7_c Abnormal cases on the network side - T3450 time-out
/*
* Increment the retransmission counter
*/
tau_proc->retransmission_count += 1;
OAILOG_WARNING(
LOG_NAS_EMM,
"EMM-PROC - T3450 timer expired, retransmission counter = %d",
tau_proc->retransmission_count);
/*
* Get the UE's EMM context
*/
if (tau_proc->retransmission_count < TAU_COUNTER_MAX) {
/*
* Send attach accept message to the UE
*/
_emm_tracking_area_update_accept(tau_proc);
} else {
/*
* Abort the attach procedure
*/
/*
* Abort the security mode control procedure
*/
emm_sap_t emm_sap = {0};
emm_sap.primitive = EMMREG_ATTACH_ABORT;
emm_sap.u.emm_reg.ue_id = tau_proc->ue_id;
emm_sap.u.emm_reg.ctx = emm_context;
emm_sap.u.emm_reg.notify = true;
emm_sap.u.emm_reg.free_proc = true;
emm_sap.u.emm_reg.u.attach.is_emergency = false;
emm_sap_send(&emm_sap);
}
}
OAILOG_FUNC_OUT(LOG_NAS_EMM);
}
/* TODO - Compiled out this function to remove compiler warnings since we don't support reauthetication and change in
* security context during periodic TAU procedure.
*/
#if 0
/** \fn void _emm_tracking_area_update_security(void *args);
\brief Performs the tracking area update procedure not accepted by the network.
@param [in]args UE EMM context data
@returns status of operation
*/
//------------------------------------------------------------------------------
static int _emm_tracking_area_update_security (emm_context_t * emm_context)
...
#endif
/** \fn _emm_tracking_area_update_reject();
\brief Performs the tracking area update procedure not accepted by the network.
@param [in]args UE EMM context data
@returns status of operation
*/
//------------------------------------------------------------------------------
static int _emm_tracking_area_update_reject(
const mme_ue_s1ap_id_t ue_id,
const int emm_cause)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
int rc = RETURNok;
emm_sap_t emm_sap = {0};
ue_mm_context_t *ue_mm_context = NULL;
emm_context_t *emm_context = NULL;
OAILOG_WARNING(
LOG_NAS_EMM,
"EMM-PROC- Sending Tracking Area Update Reject. ue_id=" MME_UE_S1AP_ID_FMT
", cause=%d)\n",
ue_id,
emm_cause);
/*
* Notify EMM-AS SAP that Tracking Area Update Reject message has to be sent
* onto the network
*/
emm_sap.primitive = EMMAS_ESTABLISH_REJ;
emm_sap.u.emm_as.u.establish.ue_id = ue_id;
emm_sap.u.emm_as.u.establish.eps_id.guti = NULL;
emm_sap.u.emm_as.u.establish.emm_cause = emm_cause;
emm_sap.u.emm_as.u.establish.nas_info = EMM_AS_NAS_INFO_TAU;
emm_sap.u.emm_as.u.establish.nas_msg = NULL;
/*
* Setup EPS NAS security data
*/
ue_mm_context =
mme_ue_context_exists_mme_ue_s1ap_id(&mme_app_desc.mme_ue_contexts, ue_id);
if (ue_mm_context) {
emm_context = &ue_mm_context->emm_context;
}
if (emm_context) {
emm_as_set_security_data(
&emm_sap.u.emm_as.u.establish.sctx,
&emm_context->_security,
false,
false);
} else {
emm_as_set_security_data(
&emm_sap.u.emm_as.u.establish.sctx, NULL, false, false);
}
rc = emm_sap_send(&emm_sap);
increment_counter("tracking_area_update", 1, 1, "action", "tau_reject_sent");
// Release EMM context
if (emm_context) {
if (emm_context->is_dynamic) {
_clear_emm_ctxt(emm_context);
}
}
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
//------------------------------------------------------------------------------
static int _build_csfb_parameters_combined_tau(
emm_context_t *emm_ctx,
emm_as_establish_t *establish)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
if (
(emm_ctx->tau_updt_type == EPS_UPDATE_TYPE_COMBINED_TA_LA_UPDATING) ||
(emm_ctx->tau_updt_type ==
EPS_UPDATE_TYPE_COMBINED_TA_LA_UPDATING_WITH_IMSI_ATTACH) ||
(emm_ctx->tau_updt_type == EPS_UPDATE_TYPE_PERIODIC_UPDATING)) {
//Check if SGS Location update procedure is successful
if (emm_ctx->csfbparams.sgs_loc_updt_status == SUCCESS) {
if (emm_ctx->csfbparams.presencemask & LAI) {
establish->location_area_identification = &emm_ctx->csfbparams.lai;
}
//Encode Mobile Identity
if (emm_ctx->csfbparams.presencemask & MOBILE_IDENTITY) {
establish->ms_identity = &emm_ctx->csfbparams.mobileid;
}
//Send Additional Update type if SMS_ONLY is enabled
if (
(emm_ctx->csfbparams.presencemask & ADD_UPDATE_TYPE) &&
(emm_ctx->csfbparams.additional_updt_res ==
ADDITONAL_UPDT_RES_SMS_ONLY)) {
establish->additional_update_result =
&emm_ctx->csfbparams.additional_updt_res;
}
establish->eps_update_result = EPS_UPDATE_RESULT_COMBINED_TA_LA_UPDATED;
} else if (emm_ctx->csfbparams.sgs_loc_updt_status == FAILURE) {
establish->combined_tau_emm_cause = &emm_ctx->emm_cause;
establish->eps_update_result = EPS_UPDATE_RESULT_TA_UPDATED;
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNok);
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, RETURNerror);
}
/** \fn void _emm_tracking_area_update_accept (emm_context_t * emm_context,tau_data_t * data);
\brief Sends ATTACH ACCEPT message and start timer T3450.
@param [in]emm_context UE EMM context data
@param [in]data UE TAU accept data
@returns status of operation (RETURNok, RETURNerror)
*/
//------------------------------------------------------------------------------
static int _emm_tracking_area_update_accept(nas_emm_tau_proc_t *const tau_proc)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
int rc = RETURNerror;
emm_sap_t emm_sap = {0};
ue_mm_context_t *ue_mm_context = NULL;
emm_context_t *emm_context = NULL;
if ((tau_proc) && (tau_proc->ies)) {
ue_mm_context = mme_ue_context_exists_mme_ue_s1ap_id(
&mme_app_desc.mme_ue_contexts, tau_proc->ue_id);
if (ue_mm_context) {
emm_context = &ue_mm_context->emm_context;
} else {
OAILOG_ERROR(
LOG_NAS_EMM,"Failed to get emm context for ue_id"
"" MME_UE_S1AP_ID_FMT " \n", tau_proc->ue_id);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
if ((tau_proc->ies->eps_update_type.active_flag) &&
(ue_mm_context->ecm_state != ECM_CONNECTED)) {
/* If active flag is set to true in TAU request then re-establish bearer also for the UE while sending TAU
* Accept message
*/
emm_sap.primitive = EMMAS_ESTABLISH_CNF;
emm_sap.u.emm_as.u.establish.ue_id = tau_proc->ue_id;
emm_sap.u.emm_as.u.establish.eps_update_result =
EPS_UPDATE_RESULT_TA_UPDATED;
emm_sap.u.emm_as.u.establish.eps_id.guti = &emm_context->_guti;
emm_sap.u.emm_as.u.establish.new_guti = NULL;
emm_sap.u.emm_as.u.establish.tai_list.numberoflists = 0;
emm_sap.u.emm_as.u.establish.nas_info = EMM_AS_NAS_INFO_TAU;
/*Send eps_bearer_context_status in TAU Accept if received in TAU Req*/
if (tau_proc->ies->eps_bearer_context_status) {
emm_sap.u.emm_as.u.establish.eps_bearer_context_status =
tau_proc->ies->eps_bearer_context_status;
}
// TODO Reminder
emm_sap.u.emm_as.u.establish.location_area_identification = NULL;
emm_sap.u.emm_as.u.establish.combined_tau_emm_cause = NULL;
emm_sap.u.emm_as.u.establish.t3423 = NULL;
emm_sap.u.emm_as.u.establish.t3412 = NULL;
emm_sap.u.emm_as.u.establish.t3402 = NULL;
// TODO Reminder
emm_sap.u.emm_as.u.establish.equivalent_plmns = NULL;
emm_sap.u.emm_as.u.establish.emergency_number_list = NULL;
emm_sap.u.emm_as.u.establish.eps_network_feature_support =
&_emm_data.conf.eps_network_feature_support;
emm_sap.u.emm_as.u.establish.additional_update_result = NULL;
emm_sap.u.emm_as.u.establish.t3412_extended = NULL;
emm_sap.u.emm_as.u.establish.nas_msg =
NULL; // No ESM container message in TAU Accept message
//If CSFB is enabled, encode LAI,Mobile Id and Additional Update Type
if (
(_esm_data.conf.features & MME_API_CSFB_SMS_SUPPORTED) ||
(_esm_data.conf.features & MME_API_SMS_SUPPORTED)) {
OAILOG_INFO(
LOG_NAS_EMM, "Encoding _build_csfb_parameters_combined_tau\n");
if (
_build_csfb_parameters_combined_tau(
emm_context, &emm_sap.u.emm_as.u.establish) == RETURNerror) {
OAILOG_ERROR(
LOG_NAS_EMM,
"EMM-PROC - Error in encoding Combined TAU parameters for CSFB"
" %u\n",
tau_proc->ue_id);
}
}
/*
* Setup EPS NAS security data
*/
emm_as_set_security_data(
&emm_sap.u.emm_as.u.establish.sctx,
&emm_context->_security,
false,
true);
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - encryption = 0x%X\n",
emm_sap.u.emm_as.u.establish.encryption);
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - integrity = 0x%X\n",
emm_sap.u.emm_as.u.establish.integrity);
emm_sap.u.emm_as.u.establish.encryption =
emm_context->_security.selected_algorithms.encryption;
emm_sap.u.emm_as.u.establish.integrity =
emm_context->_security.selected_algorithms.integrity;
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - encryption = 0x%X (0x%X)\n",
emm_sap.u.emm_as.u.establish.encryption,
emm_context->_security.selected_algorithms.encryption);
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - integrity = 0x%X (0x%X)\n",
emm_sap.u.emm_as.u.establish.integrity,
emm_context->_security.selected_algorithms.integrity);
rc = emm_sap_send(&emm_sap);
//Check if new TMSI is allocated as part of Combined TAU
if (rc != RETURNerror) {
if (
(emm_sap.u.emm_as.u.establish.new_guti != NULL) ||
(emm_context->csfbparams.newTmsiAllocated)) {
/*
* Re-start T3450 timer
*/
void *timer_callback_arg = NULL;
nas_stop_T3450(tau_proc->ue_id, &tau_proc->T3450, timer_callback_arg);
nas_start_T3450(
tau_proc->ue_id,
&tau_proc->T3450,
tau_proc->emm_spec_proc.emm_proc.base_proc.time_out,
emm_context);
unlock_ue_contexts(ue_mm_context);
increment_counter(
"tracking_area_update",
1,
1,
"action",
" initial_ictr_tau_accept_sent");
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
}
nas_delete_tau_procedure(emm_context);
} // Active Flag
else {
/* If active flag is not set to true in TAU request then just send TAU accept. After sending TAU accept initiate
* S1 context release procedure for the UE if new GUTI is not sent in TAU accept message. Note - At present implicit GUTI
* reallocation is not supported and hence GUTI is not sent in TAU accept message.
*/
emm_as_data_t *emm_as = &emm_sap.u.emm_as.u.data;
/*
* Setup NAS information message to transfer
*/
emm_as->nas_info = EMM_AS_NAS_DATA_TAU;
emm_as->nas_msg = NULL; // No ESM container
/*
* Set the UE identifier
*/
emm_as->ue_id = tau_proc->ue_id;
/*Send eps_bearer_context_status in TAU Accept if received in TAU Req*/
if (tau_proc->ies->eps_bearer_context_status) {
emm_as->eps_bearer_context_status =
tau_proc->ies->eps_bearer_context_status;
}
emm_as->eps_network_feature_support =
&_emm_data.conf.eps_network_feature_support;
/*If CSFB is enabled,store LAI,Mobile Identity and
* Additional Update type to be sent in TAU accept to S1AP
*/
if (
(_esm_data.conf.features & MME_API_CSFB_SMS_SUPPORTED) ||
(_esm_data.conf.features & MME_API_SMS_SUPPORTED)) {
if (emm_context->csfbparams.sgs_loc_updt_status == SUCCESS) {
if (emm_context->csfbparams.presencemask & LAI) {
emm_as->location_area_identification = &emm_context->csfbparams.lai;
}
if (emm_context->csfbparams.presencemask & MOBILE_IDENTITY) {
emm_as->ms_identity = &emm_context->csfbparams.mobileid;
}
if (emm_context->csfbparams.presencemask & ADD_UPDATE_TYPE) {
emm_as->additional_update_result =
&emm_context->csfbparams.additional_updt_res;
}
emm_as->sgs_loc_updt_status = SUCCESS;
} else if (emm_context->csfbparams.sgs_loc_updt_status == FAILURE) {
emm_as->sgs_loc_updt_status = FAILURE;
emm_as->sgs_reject_cause = (uint32_t *) &emm_context->emm_cause;
}
}
/*
* Setup EPS NAS security data
*/
emm_as_set_security_data(
&emm_as->sctx, &emm_context->_security, false, true);
/*
* Notify EMM-AS SAP that TAU Accept message has to be sent to the network
*/
emm_sap.primitive = EMMAS_DATA_REQ;
rc = emm_sap_send(&emm_sap);
increment_counter(
"tracking_area_update", 1, 1, "action", "tau_accept_sent");
// Start T3450 timer if new TMSI is allocated
if (emm_context->csfbparams.newTmsiAllocated) {
if (tau_proc->T3450.id != NAS_TIMER_INACTIVE_ID) {
/*
* Re-start T3450 timer
*/
nas_stop_T3450(tau_proc->ue_id, &tau_proc->T3450, NULL);
nas_start_T3450(
tau_proc->ue_id,
&tau_proc->T3450,
tau_proc->emm_spec_proc.emm_proc.base_proc.time_out,
emm_context);
} else {
/*
* Start T3450 timer
*/
nas_start_T3450(
tau_proc->ue_id,
&tau_proc->T3450,
tau_proc->emm_spec_proc.emm_proc.base_proc.time_out,
emm_context);
}
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - Timer T3450 (%ld) expires in %ld"
" seconds (TAU)",
tau_proc->T3450.id,
tau_proc->T3450.sec);
} else {
nas_delete_tau_procedure(emm_context);
}
}
} else {
OAILOG_WARNING(LOG_NAS_EMM, "EMM-PROC - TAU procedure NULL");
}
unlock_ue_contexts(ue_mm_context);
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
//------------------------------------------------------------------------------
static int _emm_tracking_area_update_abort(
struct emm_context_s *emm_context,
struct nas_base_proc_s *base_proc)
{
OAILOG_FUNC_IN(LOG_NAS_EMM);
int rc = RETURNerror;
if (emm_context) {
nas_emm_tau_proc_t *tau_proc = get_nas_specific_procedure_tau(emm_context);
if (tau_proc) {
mme_ue_s1ap_id_t ue_id =
PARENT_STRUCT(emm_context, struct ue_mm_context_s, emm_context)
->mme_ue_s1ap_id;
OAILOG_WARNING(
LOG_NAS_EMM,
"EMM-PROC - Abort the TAU procedure (ue_id=" MME_UE_S1AP_ID_FMT ")",
ue_id);
/*
* Stop timer T3450
*/
void *timer_callback_args = NULL;
nas_stop_T3450(tau_proc->ue_id, &tau_proc->T3450, timer_callback_args);
/*
* Notify EMM that EPS attach procedure failed
*/
emm_sap_t emm_sap = {0};
emm_sap.primitive = EMMREG_ATTACH_REJ;
emm_sap.u.emm_reg.ue_id = ue_id;
emm_sap.u.emm_reg.ctx = emm_context;
rc = emm_sap_send(&emm_sap);
}
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
//------------------------------------------------------------------------------
void free_emm_tau_request_ies(emm_tau_request_ies_t **const ies)
{
if ((*ies)->additional_guti) {
free_wrapper((void **) &((*ies)->additional_guti));
}
if ((*ies)->ue_network_capability) {
free_wrapper((void **) &((*ies)->ue_network_capability));
}
if ((*ies)->last_visited_registered_tai) {
free_wrapper((void **) &((*ies)->last_visited_registered_tai));
}
if ((*ies)->last_visited_registered_tai) {
free_wrapper((void **) &((*ies)->last_visited_registered_tai));
}
if ((*ies)->drx_parameter) {
free_wrapper((void **) &((*ies)->drx_parameter));
}
if ((*ies)->eps_bearer_context_status) {
free_wrapper((void **) &((*ies)->eps_bearer_context_status));
}
if ((*ies)->ms_network_capability) {
free_wrapper((void **) &((*ies)->ms_network_capability));
}
if ((*ies)->tmsi_status) {
free_wrapper((void **) &((*ies)->tmsi_status));
}
if ((*ies)->mobile_station_classmark2) {
free_wrapper((void **) &((*ies)->mobile_station_classmark2));
}
if ((*ies)->mobile_station_classmark3) {
free_wrapper((void **) &((*ies)->mobile_station_classmark3));
}
if ((*ies)->supported_codecs) {
free_wrapper((void **) &((*ies)->supported_codecs));
}
if ((*ies)->additional_updatetype) {
free_wrapper((void **) &((*ies)->additional_updatetype));
}
if ((*ies)->old_guti_type) {
free_wrapper((void **) &((*ies)->old_guti_type));
}
free_wrapper((void **) ies);
}
/****************************************************************************
** **
** Name: emm_proc_tau_complete() **
** **
** Description: Terminates the TAU procedure upon receiving TAU **
** Complete message from the UE. **
** **
** 3GPP TS 24.301, section 5.5.1.2.4 **
** Upon receiving an TAU COMPLETE message, the MME shall **
** stop timer T3450,send S1 UE context release if Active flag is **
** not set **
** **
** Inputs: ue_id: UE lower layer identifier **
** Others: _emm_data **
** **
** Outputs: None **
** Return: RETURNok, RETURNerror **
** Others: _emm_data, T3450 **
** **
***************************************************************************/
int emm_proc_tau_complete(mme_ue_s1ap_id_t ue_id)
{
emm_context_t *emm_ctx = NULL;
int rc = RETURNok;
OAILOG_FUNC_IN(LOG_NAS_EMM);
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - EPS TAU complete (ue_id=" MME_UE_S1AP_ID_FMT ")\n",
ue_id);
REQUIREMENT_3GPP_24_301(R10_5_5_1_2_4__20);
/*
* Release retransmission timer parameters
*/
emm_proc_common_clear_args(ue_id);
/*
* Get the UE context
*/
emm_ctx = emm_context_get(&_emm_data, ue_id);
if (emm_ctx) {
/*
* Upon receiving an TAU COMPLETE message, the MME shall stop timer T3450
*/
nas_emm_tau_proc_t *tau_proc = get_nas_specific_procedure_tau(emm_ctx);
if (tau_proc) {
OAILOG_INFO(
LOG_NAS_EMM,
"EMM-PROC - Stop timer T3450 (%ld)\n",
tau_proc->T3450.id);
nas_stop_T3450(tau_proc->ue_id, &tau_proc->T3450, NULL);
/*
* Upon receiving TAU COMPLETE message, the MME shall
* consider the TMSI sent in the TAU ACCEPT message as valid.
* - TODO
*/
if(emm_ctx->csfbparams.newTmsiAllocated == true) {
nas_delete_tau_procedure(emm_ctx);
}
}
//Send TMSI reallocation complete to SGS task
char imsi_str[IMSI_BCD_DIGITS_MAX + 1];
IMSI_TO_STRING(&(emm_ctx->_imsi), imsi_str, IMSI_BCD_DIGITS_MAX + 1);
//TODO-pruthvi Uncomment after merging from master
//nas_itti_sgsap_tmsi_reallocation_comp(imsi_str, strlen(imsi_str));
emm_ctx->csfbparams.newTmsiAllocated = false;
/*If Active flag is not set, send ITTI message to MME APP to
*initiate UE context release
*/
if (!emm_ctx->csfbparams.tau_active_flag) {
nas_itti_tau_complete(ue_id);
}
emm_context_unlock(emm_ctx);
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, rc);
}
static nas_emm_tau_proc_t * _emm_proc_create_procedure_tau(
ue_mm_context_t *const ue_mm_context,
emm_tau_request_ies_t *const ies) {
OAILOG_FUNC_IN(LOG_NAS_EMM);
nas_emm_tau_proc_t *tau_proc = nas_new_tau_procedure(
&ue_mm_context->emm_context);
AssertFatal(tau_proc, "TODO Handle this");
if ((tau_proc)) {
tau_proc->ies = ies;
tau_proc->ue_id = ue_mm_context->mme_ue_s1ap_id;
tau_proc->emm_spec_proc.emm_proc.base_proc.abort =
_emm_tracking_area_update_abort;
tau_proc->emm_spec_proc.emm_proc.base_proc.fail_in =
NULL; // No parent procedure
tau_proc->emm_spec_proc.emm_proc.base_proc.time_out =
_emm_tracking_area_update_t3450_handler;
tau_proc->emm_spec_proc.emm_proc.base_proc.fail_out =
NULL;
OAILOG_FUNC_RETURN(LOG_NAS_EMM, tau_proc);
}
OAILOG_FUNC_RETURN(LOG_NAS_EMM, NULL);
}
|
367795.c | /* Copyright (C) 1995-1998 Eric Young ([email protected])
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young ([email protected]).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson ([email protected]).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young ([email protected])"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson ([email protected])"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.] */
#include <openssl/bn.h>
#include <assert.h>
#include <limits.h>
#include <openssl/err.h>
#include "internal.h"
#if !defined(BN_ULLONG)
/* bn_div_words divides a double-width |h|,|l| by |d| and returns the result,
* which must fit in a |BN_ULONG|. */
static BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d) {
BN_ULONG dh, dl, q, ret = 0, th, tl, t;
int i, count = 2;
if (d == 0) {
return BN_MASK2;
}
i = BN_num_bits_word(d);
assert((i == BN_BITS2) || (h <= (BN_ULONG)1 << i));
i = BN_BITS2 - i;
if (h >= d) {
h -= d;
}
if (i) {
d <<= i;
h = (h << i) | (l >> (BN_BITS2 - i));
l <<= i;
}
dh = (d & BN_MASK2h) >> BN_BITS4;
dl = (d & BN_MASK2l);
for (;;) {
if ((h >> BN_BITS4) == dh) {
q = BN_MASK2l;
} else {
q = h / dh;
}
th = q * dh;
tl = dl * q;
for (;;) {
t = h - th;
if ((t & BN_MASK2h) ||
((tl) <= ((t << BN_BITS4) | ((l & BN_MASK2h) >> BN_BITS4)))) {
break;
}
q--;
th -= dh;
tl -= dl;
}
t = (tl >> BN_BITS4);
tl = (tl << BN_BITS4) & BN_MASK2h;
th += t;
if (l < tl) {
th++;
}
l -= tl;
if (h < th) {
h += d;
q--;
}
h -= th;
if (--count == 0) {
break;
}
ret = q << BN_BITS4;
h = ((h << BN_BITS4) | (l >> BN_BITS4)) & BN_MASK2;
l = (l & BN_MASK2l) << BN_BITS4;
}
ret |= q;
return ret;
}
#endif /* !defined(BN_ULLONG) */
static inline void bn_div_rem_words(BN_ULONG *quotient_out, BN_ULONG *rem_out,
BN_ULONG n0, BN_ULONG n1, BN_ULONG d0) {
/* GCC and Clang generate function calls to |__udivdi3| and |__umoddi3| when
* the |BN_ULLONG|-based C code is used.
*
* GCC bugs:
* * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=14224
* * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43721
* * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54183
* * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58897
* * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65668
*
* Clang bugs:
* * https://llvm.org/bugs/show_bug.cgi?id=6397
* * https://llvm.org/bugs/show_bug.cgi?id=12418
*
* These issues aren't specific to x86 and x86_64, so it might be worthwhile
* to add more assembly language implementations. */
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__GNUC__)
__asm__ volatile (
"divl %4"
: "=a"(*quotient_out), "=d"(*rem_out)
: "a"(n1), "d"(n0), "rm"(d0)
: "cc" );
#elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__GNUC__)
__asm__ volatile (
"divq %4"
: "=a"(*quotient_out), "=d"(*rem_out)
: "a"(n1), "d"(n0), "rm"(d0)
: "cc" );
#else
#if defined(BN_ULLONG)
BN_ULLONG n = (((BN_ULLONG)n0) << BN_BITS2) | n1;
*quotient_out = (BN_ULONG)(n / d0);
#else
*quotient_out = bn_div_words(n0, n1, d0);
#endif
*rem_out = n1 - (*quotient_out * d0);
#endif
}
/* BN_div computes dv := num / divisor, rounding towards
* zero, and sets up rm such that dv*divisor + rm = num holds.
* Thus:
* dv->neg == num->neg ^ divisor->neg (unless the result is zero)
* rm->neg == num->neg (unless the remainder is zero)
* If 'dv' or 'rm' is NULL, the respective value is not returned.
*
* This was specifically designed to contain fewer branches that may leak
* sensitive information; see "New Branch Prediction Vulnerabilities in OpenSSL
* and Necessary Software Countermeasures" by Onur Acıçmez, Shay Gueron, and
* Jean-Pierre Seifert. */
int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
BN_CTX *ctx) {
int norm_shift, i, loop;
BIGNUM *tmp, wnum, *snum, *sdiv, *res;
BN_ULONG *resp, *wnump;
BN_ULONG d0, d1;
int num_n, div_n;
/* Invalid zero-padding would have particularly bad consequences
* so don't just rely on bn_check_top() here */
if ((num->top > 0 && num->d[num->top - 1] == 0) ||
(divisor->top > 0 && divisor->d[divisor->top - 1] == 0)) {
OPENSSL_PUT_ERROR(BN, BN_R_NOT_INITIALIZED);
return 0;
}
if (BN_is_zero(divisor)) {
OPENSSL_PUT_ERROR(BN, BN_R_DIV_BY_ZERO);
return 0;
}
BN_CTX_start(ctx);
tmp = BN_CTX_get(ctx);
snum = BN_CTX_get(ctx);
sdiv = BN_CTX_get(ctx);
if (dv == NULL) {
res = BN_CTX_get(ctx);
} else {
res = dv;
}
if (sdiv == NULL || res == NULL || tmp == NULL || snum == NULL) {
goto err;
}
/* First we normalise the numbers */
norm_shift = BN_BITS2 - ((BN_num_bits(divisor)) % BN_BITS2);
if (!(BN_lshift(sdiv, divisor, norm_shift))) {
goto err;
}
sdiv->neg = 0;
norm_shift += BN_BITS2;
if (!(BN_lshift(snum, num, norm_shift))) {
goto err;
}
snum->neg = 0;
/* Since we don't want to have special-case logic for the case where snum is
* larger than sdiv, we pad snum with enough zeroes without changing its
* value. */
if (snum->top <= sdiv->top + 1) {
if (!bn_wexpand(snum, sdiv->top + 2)) {
goto err;
}
for (i = snum->top; i < sdiv->top + 2; i++) {
snum->d[i] = 0;
}
snum->top = sdiv->top + 2;
} else {
if (!bn_wexpand(snum, snum->top + 1)) {
goto err;
}
snum->d[snum->top] = 0;
snum->top++;
}
div_n = sdiv->top;
num_n = snum->top;
loop = num_n - div_n;
/* Lets setup a 'window' into snum
* This is the part that corresponds to the current
* 'area' being divided */
wnum.neg = 0;
wnum.d = &(snum->d[loop]);
wnum.top = div_n;
/* only needed when BN_ucmp messes up the values between top and max */
wnum.dmax = snum->dmax - loop; /* so we don't step out of bounds */
/* Get the top 2 words of sdiv */
/* div_n=sdiv->top; */
d0 = sdiv->d[div_n - 1];
d1 = (div_n == 1) ? 0 : sdiv->d[div_n - 2];
/* pointer to the 'top' of snum */
wnump = &(snum->d[num_n - 1]);
/* Setup to 'res' */
res->neg = (num->neg ^ divisor->neg);
if (!bn_wexpand(res, (loop + 1))) {
goto err;
}
res->top = loop - 1;
resp = &(res->d[loop - 1]);
/* space for temp */
if (!bn_wexpand(tmp, (div_n + 1))) {
goto err;
}
/* if res->top == 0 then clear the neg value otherwise decrease
* the resp pointer */
if (res->top == 0) {
res->neg = 0;
} else {
resp--;
}
for (i = 0; i < loop - 1; i++, wnump--, resp--) {
BN_ULONG q, l0;
/* the first part of the loop uses the top two words of snum and sdiv to
* calculate a BN_ULONG q such that | wnum - sdiv * q | < sdiv */
BN_ULONG n0, n1, rem = 0;
n0 = wnump[0];
n1 = wnump[-1];
if (n0 == d0) {
q = BN_MASK2;
} else {
/* n0 < d0 */
bn_div_rem_words(&q, &rem, n0, n1, d0);
#ifdef BN_ULLONG
BN_ULLONG t2 = (BN_ULLONG)d1 * q;
for (;;) {
if (t2 <= ((((BN_ULLONG)rem) << BN_BITS2) | wnump[-2])) {
break;
}
q--;
rem += d0;
if (rem < d0) {
break; /* don't let rem overflow */
}
t2 -= d1;
}
#else /* !BN_ULLONG */
BN_ULONG t2l, t2h;
BN_UMULT_LOHI(t2l, t2h, d1, q);
for (;;) {
if ((t2h < rem) || ((t2h == rem) && (t2l <= wnump[-2]))) {
break;
}
q--;
rem += d0;
if (rem < d0) {
break; /* don't let rem overflow */
}
if (t2l < d1) {
t2h--;
}
t2l -= d1;
}
#endif /* !BN_ULLONG */
}
l0 = bn_mul_words(tmp->d, sdiv->d, div_n, q);
tmp->d[div_n] = l0;
wnum.d--;
/* ingore top values of the bignums just sub the two
* BN_ULONG arrays with bn_sub_words */
if (bn_sub_words(wnum.d, wnum.d, tmp->d, div_n + 1)) {
/* Note: As we have considered only the leading
* two BN_ULONGs in the calculation of q, sdiv * q
* might be greater than wnum (but then (q-1) * sdiv
* is less or equal than wnum)
*/
q--;
if (bn_add_words(wnum.d, wnum.d, sdiv->d, div_n)) {
/* we can't have an overflow here (assuming
* that q != 0, but if q == 0 then tmp is
* zero anyway) */
(*wnump)++;
}
}
/* store part of the result */
*resp = q;
}
bn_correct_top(snum);
if (rm != NULL) {
/* Keep a copy of the neg flag in num because if rm==num
* BN_rshift() will overwrite it.
*/
int neg = num->neg;
if (!BN_rshift(rm, snum, norm_shift)) {
goto err;
}
if (!BN_is_zero(rm)) {
rm->neg = neg;
}
}
bn_correct_top(res);
BN_CTX_end(ctx);
return 1;
err:
BN_CTX_end(ctx);
return 0;
}
int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx) {
if (!(BN_mod(r, m, d, ctx))) {
return 0;
}
if (!r->neg) {
return 1;
}
/* now -|d| < r < 0, so we have to set r := r + |d|. */
return (d->neg ? BN_sub : BN_add)(r, r, d);
}
int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
BN_CTX *ctx) {
if (!BN_add(r, a, b)) {
return 0;
}
return BN_nnmod(r, r, m, ctx);
}
int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
const BIGNUM *m) {
if (!BN_uadd(r, a, b)) {
return 0;
}
if (BN_ucmp(r, m) >= 0) {
return BN_usub(r, r, m);
}
return 1;
}
int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
BN_CTX *ctx) {
if (!BN_sub(r, a, b)) {
return 0;
}
return BN_nnmod(r, r, m, ctx);
}
/* BN_mod_sub variant that may be used if both a and b are non-negative
* and less than m */
int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
const BIGNUM *m) {
if (!BN_sub(r, a, b)) {
return 0;
}
if (r->neg) {
return BN_add(r, r, m);
}
return 1;
}
int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
BN_CTX *ctx) {
BIGNUM *t;
int ret = 0;
BN_CTX_start(ctx);
t = BN_CTX_get(ctx);
if (t == NULL) {
goto err;
}
if (a == b) {
if (!BN_sqr(t, a, ctx)) {
goto err;
}
} else {
if (!BN_mul(t, a, b, ctx)) {
goto err;
}
}
if (!BN_nnmod(r, t, m, ctx)) {
goto err;
}
ret = 1;
err:
BN_CTX_end(ctx);
return ret;
}
int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx) {
if (!BN_sqr(r, a, ctx)) {
return 0;
}
/* r->neg == 0, thus we don't need BN_nnmod */
return BN_mod(r, r, m, ctx);
}
int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
BN_CTX *ctx) {
BIGNUM *abs_m = NULL;
int ret;
if (!BN_nnmod(r, a, m, ctx)) {
return 0;
}
if (m->neg) {
abs_m = BN_dup(m);
if (abs_m == NULL) {
return 0;
}
abs_m->neg = 0;
}
ret = BN_mod_lshift_quick(r, r, n, (abs_m ? abs_m : m));
BN_free(abs_m);
return ret;
}
int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m) {
if (r != a) {
if (BN_copy(r, a) == NULL) {
return 0;
}
}
while (n > 0) {
int max_shift;
/* 0 < r < m */
max_shift = BN_num_bits(m) - BN_num_bits(r);
/* max_shift >= 0 */
if (max_shift < 0) {
OPENSSL_PUT_ERROR(BN, BN_R_INPUT_NOT_REDUCED);
return 0;
}
if (max_shift > n) {
max_shift = n;
}
if (max_shift) {
if (!BN_lshift(r, r, max_shift)) {
return 0;
}
n -= max_shift;
} else {
if (!BN_lshift1(r, r)) {
return 0;
}
--n;
}
/* BN_num_bits(r) <= BN_num_bits(m) */
if (BN_cmp(r, m) >= 0) {
if (!BN_sub(r, r, m)) {
return 0;
}
}
}
return 1;
}
int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx) {
if (!BN_lshift1(r, a)) {
return 0;
}
return BN_nnmod(r, r, m, ctx);
}
int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m) {
if (!BN_lshift1(r, a)) {
return 0;
}
if (BN_cmp(r, m) >= 0) {
return BN_sub(r, r, m);
}
return 1;
}
BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w) {
BN_ULONG ret = 0;
int i, j;
w &= BN_MASK2;
if (!w) {
/* actually this an error (division by zero) */
return (BN_ULONG) - 1;
}
if (a->top == 0) {
return 0;
}
/* normalize input for |bn_div_rem_words|. */
j = BN_BITS2 - BN_num_bits_word(w);
w <<= j;
if (!BN_lshift(a, a, j)) {
return (BN_ULONG) - 1;
}
for (i = a->top - 1; i >= 0; i--) {
BN_ULONG l = a->d[i];
BN_ULONG d;
BN_ULONG unused_rem;
bn_div_rem_words(&d, &unused_rem, ret, l, w);
ret = (l - ((d * w) & BN_MASK2)) & BN_MASK2;
a->d[i] = d;
}
if ((a->top > 0) && (a->d[a->top - 1] == 0)) {
a->top--;
}
if (a->top == 0) {
a->neg = 0;
}
ret >>= j;
return ret;
}
BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w) {
#ifndef BN_ULLONG
BN_ULONG ret = 0;
#else
BN_ULLONG ret = 0;
#endif
int i;
if (w == 0) {
return (BN_ULONG) -1;
}
#ifndef BN_ULLONG
/* If |w| is too long and we don't have |BN_ULLONG| then we need to fall back
* to using |BN_div_word|. */
if (w > ((BN_ULONG)1 << BN_BITS4)) {
BIGNUM *tmp = BN_dup(a);
if (tmp == NULL) {
return (BN_ULONG)-1;
}
ret = BN_div_word(tmp, w);
BN_free(tmp);
return ret;
}
#endif
w &= BN_MASK2;
for (i = a->top - 1; i >= 0; i--) {
#ifndef BN_ULLONG
ret = ((ret << BN_BITS4) | ((a->d[i] >> BN_BITS4) & BN_MASK2l)) % w;
ret = ((ret << BN_BITS4) | (a->d[i] & BN_MASK2l)) % w;
#else
ret = (BN_ULLONG)(((ret << (BN_ULLONG)BN_BITS2) | a->d[i]) % (BN_ULLONG)w);
#endif
}
return (BN_ULONG)ret;
}
int BN_mod_pow2(BIGNUM *r, const BIGNUM *a, size_t e) {
if (e == 0 || a->top == 0) {
BN_zero(r);
return 1;
}
size_t num_words = 1 + ((e - 1) / BN_BITS2);
/* If |a| definitely has less than |e| bits, just BN_copy. */
if ((size_t) a->top < num_words) {
return BN_copy(r, a) != NULL;
}
/* Otherwise, first make sure we have enough space in |r|.
* Note that this will fail if num_words > INT_MAX. */
if (!bn_wexpand(r, num_words)) {
return 0;
}
/* Copy the content of |a| into |r|. */
OPENSSL_memcpy(r->d, a->d, num_words * sizeof(BN_ULONG));
/* If |e| isn't word-aligned, we have to mask off some of our bits. */
size_t top_word_exponent = e % (sizeof(BN_ULONG) * 8);
if (top_word_exponent != 0) {
r->d[num_words - 1] &= (((BN_ULONG) 1) << top_word_exponent) - 1;
}
/* Fill in the remaining fields of |r|. */
r->neg = a->neg;
r->top = (int) num_words;
bn_correct_top(r);
return 1;
}
int BN_nnmod_pow2(BIGNUM *r, const BIGNUM *a, size_t e) {
if (!BN_mod_pow2(r, a, e)) {
return 0;
}
/* If the returned value was non-negative, we're done. */
if (BN_is_zero(r) || !r->neg) {
return 1;
}
size_t num_words = 1 + (e - 1) / BN_BITS2;
/* Expand |r| to the size of our modulus. */
if (!bn_wexpand(r, num_words)) {
return 0;
}
/* Clear the upper words of |r|. */
OPENSSL_memset(&r->d[r->top], 0, (num_words - r->top) * BN_BYTES);
/* Set parameters of |r|. */
r->neg = 0;
r->top = (int) num_words;
/* Now, invert every word. The idea here is that we want to compute 2^e-|x|,
* which is actually equivalent to the twos-complement representation of |x|
* in |e| bits, which is -x = ~x + 1. */
for (int i = 0; i < r->top; i++) {
r->d[i] = ~r->d[i];
}
/* If our exponent doesn't span the top word, we have to mask the rest. */
size_t top_word_exponent = e % BN_BITS2;
if (top_word_exponent != 0) {
r->d[r->top - 1] &= (((BN_ULONG) 1) << top_word_exponent) - 1;
}
/* Keep the correct_top invariant for BN_add. */
bn_correct_top(r);
/* Finally, add one, for the reason described above. */
return BN_add(r, r, BN_value_one());
}
|
720131.c | /*******************************************************************************
*
* File: gather.c
* Description: Gather access pattern.
*
* Author: Alif Ahmed
* Email: [email protected]
* Updated: Aug 06, 2019
*
******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#define N 10000
static int a[N];
static int b[N];
static int idx[N];
// initialize
void init(){
for(int i = 0; i < N; ++i){
b[i] = 2;
idx[i] = rand() % N;
}
}
//gather kernel
void gather(){
for(int i = 0; i < N; ++i){
a[i] = b[idx[i]];
}
}
//sum
int getSum(const int* arr){
int sum = 0;
for(int i = 0; i < N; ++i){
sum += arr[i];
}
return sum;
}
int main(int argc, const char** argv) {
// initialize
init();
// call gather kernel
gather();
// print result
printf("%d\n", getSum(a));
return 0;
}
|
707677.c | /* simple wrapper around the stlink_flash_write function */
// TODO - this should be done as just a simple flag to the st-util command line...
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <stlink.h>
#include <stlink/tools/flash.h>
static stlink_t *connected_stlink = NULL;
static void cleanup(int signum) {
(void)signum;
if (connected_stlink) {
/* Switch back to mass storage mode before closing. */
stlink_run(connected_stlink);
stlink_exit_debug_mode(connected_stlink);
stlink_close(connected_stlink);
}
exit(1);
}
static void usage(void)
{
puts("stlinkv1 command line: ./st-flash [--debug] [--reset] [--format <format>] [--flash=<fsize>] {read|write} /dev/sgX <path> <addr> <size>");
puts("stlinkv1 command line: ./st-flash [--debug] /dev/sgX erase");
puts("stlinkv2 command line: ./st-flash [--debug] [--reset] [--serial <serial>] [--format <format>] [--flash=<fsize>] {read|write} <path> <addr> <size>");
puts("stlinkv2 command line: ./st-flash [--debug] [--serial <serial>] erase");
puts("stlinkv2 command line: ./st-flash [--debug] [--serial <serial>] reset");
puts(" Use hex format for addr, <serial> and <size>.");
puts(" fsize: Use decimal, octal or hex by prefix 0xXXX for hex, optionally followed by k=KB, or m=MB (eg. --flash=128k)");
puts(" Format may be 'binary' (default) or 'ihex', although <addr> must be specified for binary format only.");
puts(" ./st-flash [--version]");
}
int main(int ac, char** av)
{
stlink_t* sl = NULL;
struct flash_opts o;
int err = -1;
uint8_t * mem = NULL;
o.size = 0;
if (flash_get_opts(&o, ac - 1, av + 1) == -1)
{
printf("invalid command line\n");
usage();
return -1;
}
printf("st-flash %s\n", STLINK_VERSION);
if (o.devname != NULL) /* stlinkv1 */
sl = stlink_v1_open(o.log_level, 1);
else /* stlinkv2 */
sl = stlink_open_usb(o.log_level, 1, (char *)o.serial);
if (sl == NULL)
return -1;
if ( o.flash_size != 0u && o.flash_size != sl->flash_size ) {
sl->flash_size = o.flash_size;
printf("Forcing flash size: --flash=0x%08X\n",(unsigned int)sl->flash_size);
}
sl->verbose = o.log_level;
connected_stlink = sl;
signal(SIGINT, &cleanup);
signal(SIGTERM, &cleanup);
signal(SIGSEGV, &cleanup);
if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
if (stlink_exit_dfu_mode(sl)) {
printf("Failed to exit DFU mode\n");
goto on_error;
}
}
if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
if (stlink_enter_swd_mode(sl)) {
printf("Failed to enter SWD mode\n");
goto on_error;
}
}
if (o.reset){
if (stlink_jtag_reset(sl, 2)) {
printf("Failed to reset JTAG\n");
goto on_error;
}
if (stlink_reset(sl)) {
printf("Failed to reset device\n");
goto on_error;
}
}
// Disable DMA - Set All DMA CCR Registers to zero. - AKS 1/7/2013
if (sl->chip_id == STLINK_CHIPID_STM32_F4)
{
memset(sl->q_buf,0,4);
for (int i=0;i<8;i++) {
stlink_write_mem32(sl,0x40026000+0x10+0x18*i,4);
stlink_write_mem32(sl,0x40026400+0x10+0x18*i,4);
stlink_write_mem32(sl,0x40026000+0x24+0x18*i,4);
stlink_write_mem32(sl,0x40026400+0x24+0x18*i,4);
}
}
// Core must be halted to use RAM based flashloaders
if (stlink_force_debug(sl)) {
printf("Failed to halt the core\n");
goto on_error;
}
if (stlink_status(sl)) {
printf("Failed to get Core's status\n");
goto on_error;
}
if (o.cmd == FLASH_CMD_WRITE) /* write */
{
size_t size = 0;
if(o.format == FLASH_FORMAT_IHEX) {
err = stlink_parse_ihex(o.filename, stlink_get_erased_pattern(sl), &mem, &size, &o.addr);
if (err == -1) {
printf("Cannot parse %s as Intel-HEX file\n", o.filename);
goto on_error;
}
}
if ((o.addr >= sl->flash_base) &&
(o.addr < sl->flash_base + sl->flash_size)) {
if(o.format == FLASH_FORMAT_IHEX)
err = stlink_mwrite_flash(sl, mem, (uint32_t)size, o.addr);
else
err = stlink_fwrite_flash(sl, o.filename, o.addr);
if (err == -1)
{
printf("stlink_fwrite_flash() == -1\n");
goto on_error;
}
}
else if ((o.addr >= sl->sram_base) &&
(o.addr < sl->sram_base + sl->sram_size)) {
if(o.format == FLASH_FORMAT_IHEX)
err = stlink_mwrite_sram(sl, mem, (uint32_t)size, o.addr);
else
err = stlink_fwrite_sram(sl, o.filename, o.addr);
if (err == -1)
{
printf("stlink_fwrite_sram() == -1\n");
goto on_error;
}
}
else {
err = -1;
printf("Unknown memory region\n");
goto on_error;
}
} else if (o.cmd == FLASH_CMD_ERASE)
{
err = stlink_erase_flash_mass(sl);
if (err == -1)
{
printf("stlink_erase_flash_mass() == -1\n");
goto on_error;
}
} else if (o.cmd == CMD_RESET)
{
if (stlink_jtag_reset(sl, 2)) {
printf("Failed to reset JTAG\n");
goto on_error;
}
if (stlink_reset(sl)) {
printf("Failed to reset device\n");
goto on_error;
}
}
else /* read */
{
if ((o.addr >= sl->flash_base) && (o.size == 0) &&
(o.addr < sl->flash_base + sl->flash_size))
o.size = sl->flash_size;
else if ((o.addr >= sl->sram_base) && (o.size == 0) &&
(o.addr < sl->sram_base + sl->sram_size))
o.size = sl->sram_size;
err = stlink_fread(sl, o.filename, o.format == FLASH_FORMAT_IHEX, o.addr, o.size);
if (err == -1)
{
printf("stlink_fread() == -1\n");
goto on_error;
}
}
if (o.reset){
stlink_jtag_reset(sl,2);
stlink_reset(sl);
}
/* success */
err = 0;
on_error:
stlink_exit_debug_mode(sl);
stlink_close(sl);
free(mem);
return err;
}
|
833693.c | /* eddsa-sign-test.c
Copyright (C) 2014 Niels Möller
This file is part of GNU Nettle.
GNU Nettle is free software: you can redistribute it and/or
modify it under the terms of either:
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your
option) any later version.
or
* the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your
option) any later version.
or both in parallel, as here.
GNU Nettle is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received copies of the GNU General Public License and
the GNU Lesser General Public License along with this program. If
not, see http://www.gnu.org/licenses/.
*/
#include "testutils.h"
#include "eddsa.h"
static void
test_eddsa_sign (const struct ecc_curve *ecc,
const struct nettle_hash *H,
const struct tstring *public,
const struct tstring *private,
const struct tstring *msg,
const struct tstring *ref)
{
mp_limb_t *scratch = xalloc_limbs (_eddsa_sign_itch (ecc));
size_t nbytes = 1 + ecc->p.bit_size / 8;
uint8_t *signature = xalloc (2*nbytes);
void *ctx = xalloc (H->context_size);
uint8_t *public_out = xalloc (nbytes);
uint8_t *digest = xalloc (2*nbytes);
const uint8_t *k1 = digest + nbytes;
mp_limb_t *k2 = xalloc_limbs (ecc->p.size);
ASSERT (public->length == nbytes);
ASSERT (private->length == nbytes);
ASSERT (ref->length == 2*nbytes);
_eddsa_expand_key (ecc, H, ctx, private->data,
digest, k2);
_eddsa_public_key (ecc, k2, public_out, scratch);
if (!MEMEQ (nbytes, public_out, public->data))
{
fprintf (stderr, "Bad public key from _eddsa_expand_key + _eddsa_public_key.\n");
fprintf (stderr, "got:");
print_hex (nbytes, public_out);
fprintf (stderr, "\nref:");
tstring_print_hex (public);
fprintf (stderr, "\n");
abort ();
}
H->update (ctx, nbytes, k1);
_eddsa_sign (ecc, H, public->data, ctx, k2,
msg->length, msg->data, signature, scratch);
if (!MEMEQ (2*nbytes, signature, ref->data))
{
fprintf (stderr, "Bad _eddsa_sign output.\n");
fprintf (stderr, "Public key:");
tstring_print_hex (public);
fprintf (stderr, "\nPrivate key:");
tstring_print_hex (private);
fprintf (stderr, "\nk2:");
mpn_out_str (stderr, 16, k2, ecc->p.size);
fprintf (stderr, "\nMessage (length %u):", (unsigned) msg->length);
tstring_print_hex (msg);
fprintf (stderr, "\ngot:");
print_hex (2*nbytes, signature);
fprintf (stderr, "\nref:");
tstring_print_hex (ref);
fprintf (stderr, "\n");
abort ();
}
free (scratch);
free (signature);
free (ctx);
free (digest);
free (k2);
free (public_out);
}
void test_main (void)
{
/* Based on a few of the test vectors at
http://ed25519.cr.yp.to/python/sign.input */
test_eddsa_sign (&_nettle_curve25519, &nettle_sha512,
SHEX("d75a980182b10ab7 d54bfed3c964073a"
"0ee172f3daa62325 af021a68f707511a"),
SHEX("9d61b19deffd5a60 ba844af492ec2cc4"
"4449c5697b326919 703bac031cae7f60"),
SHEX(""),
SHEX("e5564300c360ac72 9086e2cc806e828a"
"84877f1eb8e5d974 d873e06522490155"
"5fb8821590a33bac c61e39701cf9b46b"
"d25bf5f0595bbe24 655141438e7a100b"));
test_eddsa_sign (&_nettle_curve25519, &nettle_sha512,
SHEX("3d4017c3e843895a 92b70aa74d1b7ebc"
"9c982ccf2ec4968c c0cd55f12af4660c"),
SHEX("4ccd089b28ff96da 9db6c346ec114e0f"
"5b8a319f35aba624 da8cf6ed4fb8a6fb"),
SHEX("72"),
SHEX("92a009a9f0d4cab8 720e820b5f642540"
"a2b27b5416503f8f b3762223ebdb69da"
"085ac1e43e15996e 458f3613d0f11d8c"
"387b2eaeb4302aee b00d291612bb0c00"));
test_eddsa_sign (&_nettle_curve25519, &nettle_sha512,
SHEX("1ed506485b09a645 0be7c9337d9fe87e"
"f99c96f8bd11cd63 1ca160d0fd73067e"),
SHEX("f215d34fe2d757cf f9cf5c05430994de"
"587987ce45cb0459 f61ec6c825c62259"),
SHEX("fbed2a7df418ec0e 8036312ec239fcee"
"6ef97dc8c2df1f2e 14adee287808b788"
"a6072143b851d975 c8e8a0299df846b1"
"9113e38cee83da71 ea8e9bd6f57bdcd3"
"557523f4feb616ca a595aea01eb0b3d4"
"90b99b525ea4fbb9 258bc7fbb0deea8f"
"568cb2"),
SHEX("cbef65b6f3fd5809 69fc3340cfae4f7c"
"99df1340cce54626 183144ef46887163"
"4b0a5c0033534108 e1c67c0dc99d3014"
"f01084e98c95e101 4b309b1dbb2e6704"));
}
|
30455.c |
#include <qos.h>
#include <config.h>
DDS_TopicQos* ddsbench_getQos(char *qos) {
DDS_TopicQos *result = DDS_TopicQos__alloc();
DDS_DomainParticipant_get_default_topic_qos(ddsbench_dp, result);
char *ptr, ch;
for (ptr = qos; (ch = *ptr); ptr++) {
if (ch == 'v') {
result->durability.kind = DDS_VOLATILE_DURABILITY_QOS;
} else if (ch == 't') {
result->durability.kind = DDS_TRANSIENT_DURABILITY_QOS;
} else if (ch == 'p') {
result->durability.kind = DDS_PERSISTENT_DURABILITY_QOS;
} else if (ch == 'b') {
result->reliability.kind = DDS_BEST_EFFORT_RELIABILITY_QOS;
} else if (ch == 'r') {
result->reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
result->reliability.max_blocking_time.sec = 10;
result->reliability.max_blocking_time.nanosec = 0;
}
}
result->history.kind = DDS_KEEP_ALL_HISTORY_QOS;
result->resource_limits.max_samples = 100;
return result;
}
|
547425.c | /*
** libproj -- library of cartographic projections
**
** Copyright (c) 2003, 2006 Gerald I. Evenden
*/
/*
** 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.
*/
#define PJ_LIB__
#include <errno.h>
#include <math.h>
#include "proj.h"
#include "projects.h"
struct pj_opaque {
double s0;
double A1, A2, A3, A4, A5, A6;
double B1, B2, B3, B4, B5, B6, B7, B8;
double C1, C2, C3, C4, C5, C6, C7, C8;
double D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11;
void *en;
};
PROJ_HEAD(rouss, "Roussilhe Stereographic") "\n\tAzi., Ellps.";
static XY e_forward (LP lp, PJ *P) { /* Ellipsoidal, forward */
XY xy = {0.0,0.0};
struct pj_opaque *Q = P->opaque;
double s, al, cp, sp, al2, s2;
cp = cos(lp.phi);
sp = sin(lp.phi);
s = proj_mdist(lp.phi, sp, cp, Q->en) - Q->s0;
s2 = s * s;
al = lp.lam * cp / sqrt(1. - P->es * sp * sp);
al2 = al * al;
xy.x = P->k0 * al*(1.+s2*(Q->A1+s2*Q->A4)-al2*(Q->A2+s*Q->A3+s2*Q->A5
+al2*Q->A6));
xy.y = P->k0 * (al2*(Q->B1+al2*Q->B4)+
s*(1.+al2*(Q->B3-al2*Q->B6)+s2*(Q->B2+s2*Q->B8)+
s*al2*(Q->B5+s*Q->B7)));
return xy;
}
static LP e_inverse (XY xy, PJ *P) { /* Ellipsoidal, inverse */
LP lp = {0.0,0.0};
struct pj_opaque *Q = P->opaque;
double s, al, x = xy.x / P->k0, y = xy.y / P->k0, x2, y2;;
x2 = x * x;
y2 = y * y;
al = x*(1.-Q->C1*y2+x2*(Q->C2+Q->C3*y-Q->C4*x2+Q->C5*y2-Q->C7*x2*y)
+y2*(Q->C6*y2-Q->C8*x2*y));
s = Q->s0 + y*(1.+y2*(-Q->D2+Q->D8*y2))+
x2*(-Q->D1+y*(-Q->D3+y*(-Q->D5+y*(-Q->D7+y*Q->D11)))+
x2*(Q->D4+y*(Q->D6+y*Q->D10)-x2*Q->D9));
lp.phi=proj_inv_mdist(P->ctx, s, Q->en);
s = sin(lp.phi);
lp.lam=al * sqrt(1. - P->es * s * s)/cos(lp.phi);
return lp;
}
static void *destructor (PJ *P, int errlev) {
if (0==P)
return 0;
if (0==P->opaque)
return pj_default_destructor (P, errlev);
if (P->opaque->en)
pj_dealloc (P->opaque->en);
return pj_default_destructor (P, ENOMEM);
}
PJ *PROJECTION(rouss) {
double N0, es2, t, t2, R_R0_2, R_R0_4;
struct pj_opaque *Q = pj_calloc (1, sizeof (struct pj_opaque));
if (0==Q)
return pj_default_destructor(P, ENOMEM);
P->opaque = Q;
if (!((Q->en = proj_mdist_ini(P->es))))
return pj_default_destructor (P, ENOMEM);
es2 = sin(P->phi0);
Q->s0 = proj_mdist(P->phi0, es2, cos(P->phi0), Q->en);
t = 1. - (es2 = P->es * es2 * es2);
N0 = 1./sqrt(t);
R_R0_2 = t * t / P->one_es;
R_R0_4 = R_R0_2 * R_R0_2;
t = tan(P->phi0);
t2 = t * t;
Q->C1 = Q->A1 = R_R0_2 / 4.;
Q->C2 = Q->A2 = R_R0_2 * (2 * t2 - 1. - 2. * es2) / 12.;
Q->A3 = R_R0_2 * t * (1. + 4. * t2)/ ( 12. * N0);
Q->A4 = R_R0_4 / 24.;
Q->A5 = R_R0_4 * ( -1. + t2 * (11. + 12. * t2))/24.;
Q->A6 = R_R0_4 * ( -2. + t2 * (11. - 2. * t2))/240.;
Q->B1 = t / (2. * N0);
Q->B2 = R_R0_2 / 12.;
Q->B3 = R_R0_2 * (1. + 2. * t2 - 2. * es2)/4.;
Q->B4 = R_R0_2 * t * (2. - t2)/(24. * N0);
Q->B5 = R_R0_2 * t * (5. + 4.* t2)/(8. * N0);
Q->B6 = R_R0_4 * (-2. + t2 * (-5. + 6. * t2))/48.;
Q->B7 = R_R0_4 * (5. + t2 * (19. + 12. * t2))/24.;
Q->B8 = R_R0_4 / 120.;
Q->C3 = R_R0_2 * t * (1. + t2)/(3. * N0);
Q->C4 = R_R0_4 * (-3. + t2 * (34. + 22. * t2))/240.;
Q->C5 = R_R0_4 * (4. + t2 * (13. + 12. * t2))/24.;
Q->C6 = R_R0_4 / 16.;
Q->C7 = R_R0_4 * t * (11. + t2 * (33. + t2 * 16.))/(48. * N0);
Q->C8 = R_R0_4 * t * (1. + t2 * 4.)/(36. * N0);
Q->D1 = t / (2. * N0);
Q->D2 = R_R0_2 / 12.;
Q->D3 = R_R0_2 * (2 * t2 + 1. - 2. * es2) / 4.;
Q->D4 = R_R0_2 * t * (1. + t2)/(8. * N0);
Q->D5 = R_R0_2 * t * (1. + t2 * 2.)/(4. * N0);
Q->D6 = R_R0_4 * (1. + t2 * (6. + t2 * 6.))/16.;
Q->D7 = R_R0_4 * t2 * (3. + t2 * 4.)/8.;
Q->D8 = R_R0_4 / 80.;
Q->D9 = R_R0_4 * t * (-21. + t2 * (178. - t2 * 26.))/720.;
Q->D10 = R_R0_4 * t * (29. + t2 * (86. + t2 * 48.))/(96. * N0);
Q->D11 = R_R0_4 * t * (37. + t2 * 44.)/(96. * N0);
P->fwd = e_forward;
P->inv = e_inverse;
P->destructor = destructor;
return P;
}
|
560363.c | class eAICommandBase extends HumanCommandScript
{
protected eAIBase m_Unit;
protected eAIAnimationST m_Table;
void eAICommandBase(eAIBase unit, eAIAnimationST st)
{
m_Unit = unit;
m_Table = st;
}
void SetLookDirection(vector direction) { }
//! Helper functions
void AnglesToQuat(vector angles, out float[] quat)
{
vector rotationMatrix[3];
Math3D.YawPitchRollMatrix(angles, rotationMatrix);
Math3D.MatrixToQuat(rotationMatrix, quat);
}
void PrePhys_SetAngles(vector angles)
{
float rotation[4];
AnglesToQuat(angles, rotation);
PrePhys_SetRotation(rotation);
}
}; |
17313.c | /*
* Copyright (c) 2013 - present Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
typedef struct Point {
int x;
int y;
} Point;
int foo() { return 5; }
int main() { struct Point p = {1, foo() + 3}; }
int point_coords_set_correctly(Point* p) {
*p = (Point){4, 5};
return 1 / (p->x - 4);
}
struct Employee {
int ssn;
float salary;
struct date {
int date;
int month;
int year;
} doj;
} emp1;
int field_set_correctly() {
struct Employee e = {12, 3000.50, 12, 12, 2010};
return 1 / (e.ssn - 12);
}
struct dotdot {
int a;
int b;
};
struct dot {
struct dotdot x;
int y;
};
struct rect {
struct dot origin;
int z;
int size;
};
typedef struct rect rect;
int implicit_expr_set_correctly() {
rect imageDrawRect;
imageDrawRect = (rect){.size = 5};
return 1 / imageDrawRect.origin.x.a;
}
|
469316.c | /*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2005 by the Blender Foundation.
* All rights reserved.
*/
/** \file
* \ingroup modifiers
*/
#include "BLI_utildefines.h"
#include "BLI_math.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"
#include "MEM_guardedalloc.h"
#include "BKE_collision.h"
#include "BKE_global.h"
#include "BKE_lib_id.h"
#include "BKE_mesh.h"
#include "BKE_mesh_runtime.h"
#include "BKE_modifier.h"
#include "BKE_pointcache.h"
#include "BKE_scene.h"
#include "MOD_modifiertypes.h"
#include "MOD_util.h"
#include "DEG_depsgraph_query.h"
static void initData(ModifierData *md)
{
CollisionModifierData *collmd = (CollisionModifierData *)md;
collmd->x = NULL;
collmd->xnew = NULL;
collmd->current_x = NULL;
collmd->current_xnew = NULL;
collmd->current_v = NULL;
collmd->time_x = collmd->time_xnew = -1000;
collmd->mvert_num = 0;
collmd->tri_num = 0;
collmd->is_static = false;
collmd->bvhtree = NULL;
}
static void freeData(ModifierData *md)
{
CollisionModifierData *collmd = (CollisionModifierData *)md;
if (collmd) { /* Seriously? */
if (collmd->bvhtree) {
BLI_bvhtree_free(collmd->bvhtree);
collmd->bvhtree = NULL;
}
MEM_SAFE_FREE(collmd->x);
MEM_SAFE_FREE(collmd->xnew);
MEM_SAFE_FREE(collmd->current_x);
MEM_SAFE_FREE(collmd->current_xnew);
MEM_SAFE_FREE(collmd->current_v);
MEM_SAFE_FREE(collmd->tri);
collmd->time_x = collmd->time_xnew = -1000;
collmd->mvert_num = 0;
collmd->tri_num = 0;
collmd->is_static = false;
}
}
static bool dependsOnTime(ModifierData *UNUSED(md))
{
return true;
}
static void deformVerts(ModifierData *md,
const ModifierEvalContext *ctx,
Mesh *mesh,
float (*vertexCos)[3],
int numVerts)
{
CollisionModifierData *collmd = (CollisionModifierData *)md;
Mesh *mesh_src;
MVert *tempVert = NULL;
Object *ob = ctx->object;
if (mesh == NULL) {
mesh_src = MOD_deform_mesh_eval_get(ob, NULL, NULL, NULL, numVerts, false, false);
}
else {
/* Not possible to use get_mesh() in this case as we'll modify its vertices
* and get_mesh() would return 'mesh' directly. */
BKE_id_copy_ex(NULL, (ID *)mesh, (ID **)&mesh_src, LIB_ID_COPY_LOCALIZE);
}
if (!ob->pd) {
printf("CollisionModifier deformVerts: Should not happen!\n");
return;
}
if (mesh_src) {
float current_time = 0;
uint mvert_num = 0;
BKE_mesh_vert_coords_apply(mesh_src, vertexCos);
BKE_mesh_calc_normals(mesh_src);
current_time = DEG_get_ctime(ctx->depsgraph);
if (G.debug & G_DEBUG_SIMDATA) {
printf("current_time %f, collmd->time_xnew %f\n", current_time, collmd->time_xnew);
}
mvert_num = mesh_src->totvert;
if (current_time < collmd->time_xnew) {
freeData((ModifierData *)collmd);
}
else if (current_time == collmd->time_xnew) {
if (mvert_num != collmd->mvert_num) {
freeData((ModifierData *)collmd);
}
}
/* check if mesh has changed */
if (collmd->x && (mvert_num != collmd->mvert_num)) {
freeData((ModifierData *)collmd);
}
if (collmd->time_xnew == -1000) { /* first time */
collmd->x = MEM_dupallocN(mesh_src->mvert); /* frame start position */
for (uint i = 0; i < mvert_num; i++) {
/* we save global positions */
mul_m4_v3(ob->obmat, collmd->x[i].co);
}
collmd->xnew = MEM_dupallocN(collmd->x); // frame end position
collmd->current_x = MEM_dupallocN(collmd->x); // inter-frame
collmd->current_xnew = MEM_dupallocN(collmd->x); // inter-frame
collmd->current_v = MEM_dupallocN(collmd->x); // inter-frame
collmd->mvert_num = mvert_num;
{
const MLoop *mloop = mesh_src->mloop;
const MLoopTri *looptri = BKE_mesh_runtime_looptri_ensure(mesh_src);
collmd->tri_num = BKE_mesh_runtime_looptri_len(mesh_src);
MVertTri *tri = MEM_mallocN(sizeof(*tri) * collmd->tri_num, __func__);
BKE_mesh_runtime_verttri_from_looptri(tri, mloop, looptri, collmd->tri_num);
collmd->tri = tri;
}
/* create bounding box hierarchy */
collmd->bvhtree = bvhtree_build_from_mvert(
collmd->x, collmd->tri, collmd->tri_num, ob->pd->pdef_sboft);
collmd->time_x = collmd->time_xnew = current_time;
collmd->is_static = true;
}
else if (mvert_num == collmd->mvert_num) {
/* put positions to old positions */
tempVert = collmd->x;
collmd->x = collmd->xnew;
collmd->xnew = tempVert;
collmd->time_x = collmd->time_xnew;
memcpy(collmd->xnew, mesh_src->mvert, mvert_num * sizeof(MVert));
bool is_static = true;
for (uint i = 0; i < mvert_num; i++) {
/* we save global positions */
mul_m4_v3(ob->obmat, collmd->xnew[i].co);
/* detect motion */
is_static = is_static && equals_v3v3(collmd->x[i].co, collmd->xnew[i].co);
}
memcpy(collmd->current_xnew, collmd->x, mvert_num * sizeof(MVert));
memcpy(collmd->current_x, collmd->x, mvert_num * sizeof(MVert));
/* check if GUI setting has changed for bvh */
if (collmd->bvhtree) {
if (ob->pd->pdef_sboft != BLI_bvhtree_get_epsilon(collmd->bvhtree)) {
BLI_bvhtree_free(collmd->bvhtree);
collmd->bvhtree = bvhtree_build_from_mvert(
collmd->current_x, collmd->tri, collmd->tri_num, ob->pd->pdef_sboft);
}
}
/* happens on file load (ONLY when i decomment changes in readfile.c) */
if (!collmd->bvhtree) {
collmd->bvhtree = bvhtree_build_from_mvert(
collmd->current_x, collmd->tri, collmd->tri_num, ob->pd->pdef_sboft);
}
else if (!collmd->is_static || !is_static) {
/* recalc static bounding boxes */
bvhtree_update_from_mvert(collmd->bvhtree,
collmd->current_x,
collmd->current_xnew,
collmd->tri,
collmd->tri_num,
true);
}
collmd->is_static = is_static;
collmd->time_xnew = current_time;
}
else if (mvert_num != collmd->mvert_num) {
freeData((ModifierData *)collmd);
}
}
if (!ELEM(mesh_src, NULL, mesh)) {
BKE_id_free(NULL, mesh_src);
}
}
static void updateDepsgraph(ModifierData *UNUSED(md), const ModifierUpdateDepsgraphContext *ctx)
{
DEG_add_modifier_to_transform_relation(ctx->node, "Collision Modifier");
}
ModifierTypeInfo modifierType_Collision = {
/* name */ "Collision",
/* structName */ "CollisionModifierData",
/* structSize */ sizeof(CollisionModifierData),
/* type */ eModifierTypeType_OnlyDeform,
/* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_Single,
/* copyData */ NULL,
/* deformVerts */ deformVerts,
/* deformMatrices */ NULL,
/* deformVertsEM */ NULL,
/* deformMatricesEM */ NULL,
/* applyModifier */ NULL,
/* initData */ initData,
/* requiredDataMask */ NULL,
/* freeData */ freeData,
/* isDisabled */ NULL,
/* updateDepsgraph */ updateDepsgraph,
/* dependsOnTime */ dependsOnTime,
/* dependsOnNormals */ NULL,
/* foreachObjectLink */ NULL,
/* foreachIDLink */ NULL,
/* foreachTexLink */ NULL,
/* freeRuntimeData */ NULL,
};
|
686906.c | /*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*/
#include <liblogger/liblogger.h>
#include "file_logger_impl.h"
#include "socket_logger_impl.h"
#ifndef DISABLE_THREAD_SAFETY
#include "tPLMutex.h"
#define __LOCK_MUTEX if(sMutex) PLLockMutex(sMutex)
#define __UNLOCK_MUTEX if(sMutex) PLUnLockMutex(sMutex)
#else
#define __LOCK_MUTEX /* NOP */
#define __UNLOCK_MUTEX /* NOP */
#endif // DISABLE_THREAD_SAFETY
#include <stdio.h>
#include <stdarg.h>
#ifndef DISABLE_ALL_LOGS
/** The log writer func ptr is initialized depending on the log destination. */
static LogWriter *pLogWriter = 0;
#ifndef DISABLE_THREAD_SAFETY
static tPLMutex sMutex = 0;
#endif
/** Macro to check if logger subsystem is initialize,
* if not, then it is initialized to log to file
* */
#define CHECK_AND_INIT_LOGGER if(!pLogWriter) \
{ \
fprintf(stderr,"\n[liblogger]liblogger not initialized, logging will be done to console (stdout)\n");\
if(InitLogger(LogToConsole,stdout)) \
return -1; \
if(!pLogWriter) \
return -1; \
} \
/** Function to initialize the logger. */
int InitLogger(LogDest ldest,void* loggerInitParams)
{
int retVal = 0;
if(pLogWriter)
{
fprintf(stderr,"\n [liblogger]Deinitializing the current log writer\n");
DeInitLogger();
}
#ifndef DISABLE_THREAD_SAFETY
if(!sMutex)
PLCreateMutex(&sMutex);
#endif
__LOCK_MUTEX;
switch(ldest)
{
/* log to a socket. */
case LogToSocket:
#ifndef DISABLE_SOCKET_LOGGER
{
if( -1 == InitSocketLogger(&pLogWriter,loggerInitParams) )
{
fprintf(stderr,"\n [liblogger] could not init socket logging \n");
retVal = -1;
goto UNLOCK_RETURN;
}
}
#else
{
fprintf(stderr,"\n [liblogger] Socket logger not enabled during build\n");
retVal = -1;
goto UNLOCK_RETURN;
}
#endif
break;
/* log to a console. */
case LogToConsole:
{
if( -1 == InitConsoleLogger(&pLogWriter,loggerInitParams) )
{
// control should never reach here, this should alwasy succeed.
fprintf(stderr,"\n [liblogger] could not initialize console logger \n");
retVal = -1;
goto UNLOCK_RETURN;
}
}
break;
/* log to a file. */
case LogToFile:
{
if( -1 == InitFileLogger(&pLogWriter,loggerInitParams) )
{
fprintf(stderr,"\n [liblogger] could not initialize file logger, check file path/name \n");
retVal = -1;
goto UNLOCK_RETURN;
}
}
break;
}
retVal = 0;
UNLOCK_RETURN:
__UNLOCK_MUTEX;
return retVal; // success.
}
/** Deinitialize the logger, the file / socket is closed here. */
void DeInitLogger()
{
__LOCK_MUTEX;
pLogWriter->loggerDeInit(pLogWriter);
pLogWriter = 0;
__UNLOCK_MUTEX;
#ifndef DISABLE_THREAD_SAFETY
PLDestroyMutex(&sMutex);
sMutex = 0;
#endif
}
int vsLogStub(LogLevel logLevel,
#ifdef VARIADIC_MACROS
const char* moduleName,const char* file,
const char* funcName, const int lineNum,
#endif
const char* fmt,va_list ap)
{
int retVal = 0;
CHECK_AND_INIT_LOGGER;
__LOCK_MUTEX;
retVal = pLogWriter->log(pLogWriter,logLevel,
#ifdef VARIADIC_MACROS
moduleName,file,funcName,lineNum,
#endif
fmt,ap);
__UNLOCK_MUTEX;
return retVal;
}
#ifdef VARIADIC_MACROS
int LogStub_vm(LogLevel logLevel,
const char* moduleName,const char* file,
const char* funcName, const int lineNum,
const char* fmt,...)
{
va_list ap;
int retVal = 0;
va_start(ap,fmt);
retVal = vsLogStub(logLevel,moduleName,file,funcName,lineNum,fmt,ap);
va_end(ap);
return retVal;
}
#else
int LogTrace(const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Trace,fmt,ap);
va_end(ap);
return retVal;
}
int LogDebug(const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Debug,fmt,ap);
va_end(ap);
return retVal;
}
int LogInfo(const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Info,fmt,ap);
va_end(ap);
return retVal;
}
int LogWarn(const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Warn,fmt,ap);
va_end(ap);
return retVal;
}
int LogError(const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Error,fmt,ap);
va_end(ap);
return retVal;
}
int LogFatal (const char* fmt,...)
{
int retVal = 0;
va_list ap;
va_start(ap,fmt);
retVal = vsLogStub(Fatal,fmt,ap);
va_end(ap);
return retVal;
}
#endif // VARIADIC_MACROS
int FuncLogEntry(const char* funcName)
{
int retVal = 0;
CHECK_AND_INIT_LOGGER;
__LOCK_MUTEX;
retVal = pLogWriter->logFuncEntry(pLogWriter,funcName);
__UNLOCK_MUTEX;
return retVal;
}
int FuncLogExit(const char* funcName,const int lineNumber)
{
int retVal = 0;
CHECK_AND_INIT_LOGGER;
__LOCK_MUTEX;
retVal = pLogWriter->logFuncExit(pLogWriter,funcName,lineNumber);
__UNLOCK_MUTEX;
return retVal;
}
#endif /* DISABLE_ALL_LOGS */
|
629144.c | /* mpn/generic/hgcd2.c method 1.
Copyright 2019 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of either:
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your
option) any later version.
or
* the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any
later version.
or both in parallel, as here.
The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the GNU MP Library. If not,
see https://www.gnu.org/licenses/. */
#include "gmp-impl.h"
#undef HGCD2_DIV1_METHOD
#define HGCD2_DIV1_METHOD 1
#define __gmpn_hgcd2 mpn_hgcd2_1
/* Not used, but renamed to not get duplicate definitions */
#define __gmpn_hgcd_mul_matrix1_vector mpn_hgcd_mul_matrix1_vector_1
#include "mpn/generic/hgcd2.c"
|
101109.c | /*
LUFA Library
Copyright (C) Dean Camera, 2019.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2019 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaims all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Main source file for the Keyboard demo. This file contains the main tasks of the demo and
* is responsible for the initial application hardware configuration.
*/
#include "Keyboard.h"
/** Indicates what report mode the host has requested, true for normal HID reporting mode, \c false for special boot
* protocol reporting mode.
*/
static bool UsingReportProtocol = true;
/** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
* for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
*/
static uint16_t IdleCount = 500;
/** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
* milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
* the current idle period via a Get Idle HID class request, thus its value must be preserved.
*/
static uint16_t IdleMSRemaining = 0;
/** Main program entry point. This routine configures the hardware required by the application, then
* enters a loop to run the application tasks in sequence.
*/
int main(void)
{
SetupHardware();
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
GlobalInterruptEnable();
for (;;)
{
HID_Task();
USB_USBTask();
}
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
#if (ARCH == ARCH_AVR8)
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
#elif (ARCH == ARCH_XMEGA)
/* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
/* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
#endif
/* Hardware Initialization */
Joystick_Init();
LEDs_Init();
USB_Init();
Buttons_Init();
}
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
* starts the library USB task to begin the enumeration and USB management process.
*/
void EVENT_USB_Device_Connect(void)
{
/* Indicate USB enumerating */
LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
/* Default to report protocol on connect */
UsingReportProtocol = true;
}
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
* the status LEDs.
*/
void EVENT_USB_Device_Disconnect(void)
{
/* Indicate USB not ready */
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
* of the USB device after enumeration, and configures the keyboard device endpoints.
*/
void EVENT_USB_Device_ConfigurationChanged(void)
{
bool ConfigSuccess = true;
/* Setup HID Report Endpoints */
ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
/* Turn on Start-of-Frame events for tracking HID report period expiry */
USB_Device_EnableSOFEvents();
/* Indicate endpoint configuration success or failure */
LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
}
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
* the device from the USB host before passing along unhandled control requests to the library for processing
* internally.
*/
void EVENT_USB_Device_ControlRequest(void)
{
/* Handle HID Class specific requests */
switch (USB_ControlRequest.bRequest)
{
case HID_REQ_GetReport:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
{
USB_KeyboardReport_Data_t KeyboardReportData;
/* Create the next keyboard report for transmission to the host */
CreateKeyboardReport(&KeyboardReportData);
Endpoint_ClearSETUP();
/* Write the report data to the control endpoint */
Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
Endpoint_ClearOUT();
}
break;
case HID_REQ_SetReport:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
/* Wait until the LED report has been sent by the host */
while (!(Endpoint_IsOUTReceived()))
{
if (USB_DeviceState == DEVICE_STATE_Unattached)
return;
}
/* Read in the LED report from the host */
uint8_t LEDStatus = Endpoint_Read_8();
Endpoint_ClearOUT();
Endpoint_ClearStatusStage();
/* Process the incoming LED report */
ProcessLEDReport(LEDStatus);
}
break;
case HID_REQ_GetProtocol:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
/* Write the current protocol flag to the host */
Endpoint_Write_8(UsingReportProtocol);
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
}
break;
case HID_REQ_SetProtocol:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
UsingReportProtocol = (USB_ControlRequest.wValue != 0);
}
break;
case HID_REQ_SetIdle:
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
/* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
}
break;
case HID_REQ_GetIdle:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
{
Endpoint_ClearSETUP();
/* Write the current idle duration to the host, must be divided by 4 before sent to host */
Endpoint_Write_8(IdleCount >> 2);
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
}
break;
}
}
/** Event handler for the USB device Start Of Frame event. */
void EVENT_USB_Device_StartOfFrame(void)
{
/* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
if (IdleMSRemaining)
IdleMSRemaining--;
}
/** Fills the given HID report data structure with the next HID report to send to the host.
*
* \param[out] ReportData Pointer to a HID report data structure to be filled
*/
void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
{
uint8_t JoyStatus_LCL = Joystick_GetStatus();
uint8_t ButtonStatus_LCL = Buttons_GetStatus();
uint8_t UsedKeyCodes = 0;
/* Clear the report contents */
memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
/* Make sent key uppercase by indicating that the left shift key is pressed */
ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
if (JoyStatus_LCL & JOY_UP)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
else if (JoyStatus_LCL & JOY_DOWN)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_B;
if (JoyStatus_LCL & JOY_LEFT)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_C;
else if (JoyStatus_LCL & JOY_RIGHT)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_D;
if (JoyStatus_LCL & JOY_PRESS)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_E;
if (ButtonStatus_LCL & BUTTONS_BUTTON1)
ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_F;
}
/** Processes a received LED report, and updates the board LEDs states to match.
*
* \param[in] LEDReport LED status report from the host
*/
void ProcessLEDReport(const uint8_t LEDReport)
{
uint8_t LEDMask = LEDS_LED2;
if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
LEDMask |= LEDS_LED1;
if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
LEDMask |= LEDS_LED3;
if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
LEDMask |= LEDS_LED4;
/* Set the status LEDs to the current Keyboard LED status */
LEDs_SetAllLEDs(LEDMask);
}
/** Sends the next HID report to the host, via the keyboard data endpoint. */
void SendNextReport(void)
{
static USB_KeyboardReport_Data_t PrevKeyboardReportData;
USB_KeyboardReport_Data_t KeyboardReportData;
bool SendReport = false;
/* Create the next keyboard report for transmission to the host */
CreateKeyboardReport(&KeyboardReportData);
/* Check if the idle period is set and has elapsed */
if (IdleCount && (!(IdleMSRemaining)))
{
/* Reset the idle time remaining counter */
IdleMSRemaining = IdleCount;
/* Idle period is set and has elapsed, must send a report to the host */
SendReport = true;
}
else
{
/* Check to see if the report data has changed - if so a report MUST be sent */
SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
}
/* Select the Keyboard Report Endpoint */
Endpoint_SelectEndpoint(KEYBOARD_IN_EPADDR);
/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
if (Endpoint_IsReadWriteAllowed() && SendReport)
{
/* Save the current report data for later comparison to check for changes */
PrevKeyboardReportData = KeyboardReportData;
/* Write Keyboard Report Data */
Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
/* Finalize the stream transfer to send the last packet */
Endpoint_ClearIN();
}
}
/** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
void ReceiveNextReport(void)
{
/* Select the Keyboard LED Report Endpoint */
Endpoint_SelectEndpoint(KEYBOARD_OUT_EPADDR);
/* Check if Keyboard LED Endpoint contains a packet */
if (Endpoint_IsOUTReceived())
{
/* Check to see if the packet contains data */
if (Endpoint_IsReadWriteAllowed())
{
/* Read in the LED report from the host */
uint8_t LEDReport = Endpoint_Read_8();
/* Process the read LED report from the host */
ProcessLEDReport(LEDReport);
}
/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
Endpoint_ClearOUT();
}
}
/** Function to manage HID report generation and transmission to the host, when in report mode. */
void HID_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Send the next keypress report to the host */
SendNextReport();
/* Process the LED report sent from the host */
ReceiveNextReport();
}
|
290062.c | /*
* Copyright (C) 2010 Stefan Walter
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gcr/gcr-certificate.h"
#include "gcr-certificate-renderer.h"
#include "gcr-certificate-widget.h"
#include "gcr-deprecated.h"
#include "gcr-renderer.h"
#include "gcr-viewer.h"
#include "gck/gck.h"
#include <gdk/gdk.h>
#include <glib/gi18n-lib.h>
/**
* SECTION:gcr-certificate-widget
* @title: GcrCertificateWidget
* @short_description: Certificate widget and renderer
*
* A #GcrCertificateWidget can be used to display a certificate. The widget
* is normally in a collapsed state showing only details, but can be expanded
* by the user.
*
* Use gcr_certificate_widget_new() to create a new certificate widget. Only
* one certificate can be displayed. A #GcrCertificateWidget contains a
* #GcrViewer internally and #GcrCertificateRenderer is used to render the
* certificate to the viewer. To show more than one certificate in a view,
* create the viewer and add renderers to it.
*/
/**
* GcrCertificateWidget:
*
* A widget that displays a certificate.
*/
/**
* GcrCertificateWidgetClass:
*
* The class for #GcrCertificateWidget
*/
enum {
PROP_0,
PROP_CERTIFICATE,
PROP_ATTRIBUTES
};
struct _GcrCertificateWidgetPrivate {
GcrViewer *viewer;
GcrCertificateRenderer *renderer;
};
G_DEFINE_TYPE_WITH_PRIVATE (GcrCertificateWidget, gcr_certificate_widget, GTK_TYPE_BIN);
/* -----------------------------------------------------------------------------
* OBJECT
*/
static GObject*
gcr_certificate_widget_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GObject *obj = G_OBJECT_CLASS (gcr_certificate_widget_parent_class)->constructor (type, n_props, props);
GcrCertificateWidget *self = NULL;
g_return_val_if_fail (obj, NULL);
self = GCR_CERTIFICATE_WIDGET (obj);
self->pv->viewer = gcr_viewer_new_scrolled ();
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->pv->viewer));
gtk_widget_show (GTK_WIDGET (self->pv->viewer));
gcr_viewer_add_renderer (self->pv->viewer, GCR_RENDERER (self->pv->renderer));
return obj;
}
static void
gcr_certificate_widget_init (GcrCertificateWidget *self)
{
self->pv = gcr_certificate_widget_get_instance_private (self);
self->pv->renderer = gcr_certificate_renderer_new (NULL);
}
static void
gcr_certificate_widget_finalize (GObject *obj)
{
GcrCertificateWidget *self = GCR_CERTIFICATE_WIDGET (obj);
g_assert (self->pv->renderer);
g_object_unref (self->pv->renderer);
self->pv->renderer = NULL;
g_assert (self->pv->viewer);
self->pv->viewer = NULL;
G_OBJECT_CLASS (gcr_certificate_widget_parent_class)->finalize (obj);
}
static void
gcr_certificate_widget_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
GcrCertificateWidget *self = GCR_CERTIFICATE_WIDGET (obj);
switch (prop_id) {
case PROP_CERTIFICATE:
gcr_certificate_widget_set_certificate (self, g_value_get_object (value));
break;
case PROP_ATTRIBUTES:
gcr_certificate_widget_set_attributes (self, g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gcr_certificate_widget_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
GcrCertificateWidget *self = GCR_CERTIFICATE_WIDGET (obj);
switch (prop_id) {
case PROP_CERTIFICATE:
g_value_set_object (value, gcr_certificate_widget_get_certificate (self));
break;
case PROP_ATTRIBUTES:
g_value_set_boxed (value, gcr_certificate_widget_get_attributes (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gcr_certificate_widget_class_init (GcrCertificateWidgetClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gcr_certificate_widget_parent_class = g_type_class_peek_parent (klass);
gobject_class->constructor = gcr_certificate_widget_constructor;
gobject_class->finalize = gcr_certificate_widget_finalize;
gobject_class->set_property = gcr_certificate_widget_set_property;
gobject_class->get_property = gcr_certificate_widget_get_property;
g_object_class_install_property (gobject_class, PROP_CERTIFICATE,
g_param_spec_object("certificate", "Certificate", "Certificate to display.",
GCR_TYPE_CERTIFICATE, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_ATTRIBUTES,
g_param_spec_boxed ("attributes", "Attributes", "Attributes which contain the certificate",
GCK_TYPE_ATTRIBUTES, G_PARAM_READWRITE));
}
/* -----------------------------------------------------------------------------
* PUBLIC
*/
/**
* gcr_certificate_widget_new:
* @certificate: (allow-none): certificate to display, or %NULL
*
* Create a new certificate widget which displays a given certificate.
*
* Returns: (transfer full): a newly allocated #GcrCertificateWidget, which
* should be freed with g_object_unref()
*/
GcrCertificateWidget *
gcr_certificate_widget_new (GcrCertificate *certificate)
{
return g_object_new (GCR_TYPE_CERTIFICATE_WIDGET, "certificate", certificate, NULL);
}
/**
* gcr_certificate_widget_get_certificate:
* @self: The certificate widget
*
* Get the certificate displayed in the widget.
*
* Returns: (allow-none) (transfer none): the certificate
*/
GcrCertificate *
gcr_certificate_widget_get_certificate (GcrCertificateWidget *self)
{
g_return_val_if_fail (GCR_IS_CERTIFICATE_WIDGET (self), NULL);
return gcr_certificate_renderer_get_certificate (self->pv->renderer);
}
/**
* gcr_certificate_widget_set_certificate:
* @self: The certificate widget
* @certificate: (allow-none): the certificate to display
*
* Set the certificate displayed in the widget
*/
void
gcr_certificate_widget_set_certificate (GcrCertificateWidget *self, GcrCertificate *certificate)
{
g_return_if_fail (GCR_IS_CERTIFICATE_WIDGET (self));
gcr_certificate_renderer_set_certificate (self->pv->renderer, certificate);
}
/**
* gcr_certificate_widget_get_attributes:
* @self: The certificate widget
*
* Get the attributes displayed in the widget. The attributes should contain
* a certificate.
*
* Returns: (allow-none) (transfer none): the attributes, owned by the widget
*
* Deprecated: 3.6: Use gcr_renderer_get_attributes() instead
*/
GckAttributes *
gcr_certificate_widget_get_attributes (GcrCertificateWidget *self)
{
g_return_val_if_fail (GCR_IS_CERTIFICATE_WIDGET (self), NULL);
return gcr_renderer_get_attributes (GCR_RENDERER (self->pv->renderer));
}
/**
* gcr_certificate_widget_set_attributes:
* @self: The certificate widget
* @attrs: (allow-none): the attributes to display
*
* Set the attributes displayed in the widget. The attributes should contain
* a certificate.
*
* Deprecated: 3.6: Use gcr_renderer_set_attributes() instead
*/
void
gcr_certificate_widget_set_attributes (GcrCertificateWidget *self,
GckAttributes *attrs)
{
g_return_if_fail (GCR_IS_CERTIFICATE_WIDGET (self));
gcr_renderer_set_attributes (GCR_RENDERER (self->pv->renderer), attrs);
}
|
924422.c | /**
* (C) Copyright 2016-2021 Intel Corporation.
*
* SPDX-License-Identifier: BSD-2-Clause-Patent
*/
/**
* This file is part of daos
*
* src/common/pool_map.c
*/
#define D_LOGFAC DD_FAC(common)
#include <daos/pool_map.h>
#include "fault_domain.h"
/** counters for component (sub)tree */
struct pool_comp_cntr {
/** # of domains in the top level */
unsigned int cc_top_doms;
/** # of all domains */
unsigned int cc_domains;
/** # of targets */
unsigned int cc_targets;
/** # of buffer layers */
unsigned int cc_layers;
};
/** component state dictionary */
struct pool_comp_state_dict {
/** component state */
pool_comp_state_t sd_state;
/** string name for the state */
char *sd_name;
};
/** component type dictionary */
struct pool_comp_type_dict {
/** type of component */
pool_comp_type_t td_type;
/** abbreviation for the type */
char td_abbr;
/** string name for the type */
char *td_name;
};
/** data structure to help binary search of components */
struct pool_comp_sorter {
/** type of component */
pool_comp_type_t cs_type;
/** number of components */
unsigned int cs_nr;
/** pointer array for binary search */
struct pool_component **cs_comps;
};
/** In memory data structure for pool map */
struct pool_map {
/** protect the refcount */
pthread_mutex_t po_lock;
/** Current version of pool map */
uint32_t po_version;
/** refcount on the pool map */
int po_ref;
/** # domain layers */
unsigned int po_domain_layers;
/**
* Sorters for the binary search of different domain types.
* These sorters are in ascending order for binary search of sorters.
*/
struct pool_comp_sorter *po_domain_sorters;
/** sorter for binary search of target */
struct pool_comp_sorter po_target_sorter;
/**
* Tree root of all components.
* NB: All components must be stored in contiguous buffer.
*/
struct pool_domain *po_tree;
/**
* number of currently failed pool components of each type
* of component found in the pool
*/
struct pool_fail_comp *po_comp_fail_cnts;
};
static struct pool_comp_state_dict comp_state_dict[] = {
{
.sd_state = PO_COMP_ST_UP,
.sd_name = "UP",
},
{
.sd_state = PO_COMP_ST_UPIN,
.sd_name = "UP_IN",
},
{
.sd_state = PO_COMP_ST_DOWN,
.sd_name = "DOWN",
},
{
.sd_state = PO_COMP_ST_DOWNOUT,
.sd_name = "DOWN_OUT",
},
{
.sd_state = PO_COMP_ST_NEW,
.sd_name = "NEW",
},
{
.sd_state = PO_COMP_ST_DRAIN,
.sd_name = "DRAIN",
},
{
.sd_state = PO_COMP_ST_UNKNOWN,
.sd_name = "UNKNOWN",
},
};
#define comp_state_for_each(d) \
for (d = &comp_state_dict[0]; d->sd_state != PO_COMP_ST_UNKNOWN; d++)
static struct pool_comp_type_dict comp_type_dict[] = {
{
.td_type = PO_COMP_TP_TARGET,
.td_abbr = 't',
.td_name = "target",
},
{
.td_type = PO_COMP_TP_RANK,
.td_abbr = 'n',
.td_name = "node",
},
{
.td_type = PO_COMP_TP_NODE, /** for testing */
.td_abbr = 'r',
.td_name = "rack",
},
{
.td_type = PO_COMP_TP_ROOT,
.td_abbr = 'o',
.td_name = "root",
},
{
.td_type = PO_COMP_TP_END,
.td_abbr = 'e',
.td_name = "",
}
};
#define comp_type_for_each(d) \
for (d = &comp_type_dict[0]; d->td_type != PO_COMP_TP_END; d++)
/**
* struct used to keep track of failed domain count
* keeps track of each domain separately for lookup.
*/
struct pool_fail_comp {
uint32_t fail_cnt;
pool_comp_type_t comp_type;
};
static void pool_map_destroy(struct pool_map *map);
static bool pool_map_empty(struct pool_map *map);
static void pool_tree_count(struct pool_domain *tree,
struct pool_comp_cntr *cntr);
const char *
pool_comp_state2str(pool_comp_state_t state)
{
struct pool_comp_state_dict *dict;
comp_state_for_each(dict) {
if (dict->sd_state == state)
break;
}
return dict->sd_name;
}
pool_comp_state_t
pool_comp_str2state(const char *name)
{
struct pool_comp_state_dict *dict;
comp_state_for_each(dict) {
if (strcasecmp(name, dict->sd_name) == 0)
break;
}
return dict->sd_state;
}
const char *
pool_comp_type2str(pool_comp_type_t type)
{
struct pool_comp_type_dict *dict;
comp_type_for_each(dict) {
if (dict->td_type == type)
break;
}
return dict->td_name;
}
pool_comp_type_t
pool_comp_str2type(const char *name)
{
struct pool_comp_type_dict *dict;
comp_type_for_each(dict) {
if (strcasecmp(name, dict->td_name) == 0)
break;
}
return dict->td_type;
}
pool_comp_type_t
pool_comp_abbr2type(char abbr)
{
struct pool_comp_type_dict *dict;
abbr = tolower(abbr);
comp_type_for_each(dict) {
if (abbr == dict->td_abbr)
break;
}
return dict->td_type;
}
static bool
target_exist(struct pool_map *map, uint32_t id)
{
return pool_map_find_target(map, id, NULL) != 0;
}
static bool
domain_exist(struct pool_map *map, pool_comp_type_t type, uint32_t id)
{
return pool_map_find_domain(map, type, id, NULL) != 0;
}
static void
comp_sort_op_swap(void *array, int a, int b)
{
struct pool_component **comps = (struct pool_component **)array;
struct pool_component *tmp;
tmp = comps[a];
comps[a] = comps[b];
comps[b] = tmp;
}
static int
comp_sort_op_cmp(void *array, int a, int b)
{
struct pool_component **comps = (struct pool_component **)array;
if (comps[a]->co_id > comps[b]->co_id)
return 1;
if (comps[a]->co_id < comps[b]->co_id)
return -1;
return 0;
}
static int
comp_sort_op_cmp_key(void *array, int i, uint64_t key)
{
struct pool_component **comps = (struct pool_component **)array;
uint32_t id = (uint32_t)key;
if (comps[i]->co_id > id)
return 1;
if (comps[i]->co_id < id)
return -1;
return 0;
}
/** ID based sort and lookup for components */
static daos_sort_ops_t comp_sort_ops = {
.so_swap = comp_sort_op_swap,
.so_cmp = comp_sort_op_cmp,
.so_cmp_key = comp_sort_op_cmp_key,
};
static int
comp_sorter_init(struct pool_comp_sorter *sorter, int nr,
pool_comp_type_t type)
{
D_DEBUG(DB_TRACE, "Initialize sorter for %s, nr %d\n",
pool_comp_type2str(type), nr);
D_ALLOC_ARRAY(sorter->cs_comps, nr);
if (sorter->cs_comps == NULL)
return -DER_NOMEM;
sorter->cs_type = type;
sorter->cs_nr = nr;
return 0;
}
static void
comp_sorter_fini(struct pool_comp_sorter *sorter)
{
if (sorter != NULL && sorter->cs_comps != NULL) {
D_DEBUG(DB_TRACE, "Finalize sorter for %s\n",
pool_comp_type2str(sorter->cs_type));
D_FREE(sorter->cs_comps);
sorter->cs_nr = 0;
}
}
static struct pool_domain *
comp_sorter_find_domain(struct pool_comp_sorter *sorter, unsigned int id)
{
int at;
D_ASSERT(sorter->cs_type > PO_COMP_TP_TARGET);
at = daos_array_find(sorter->cs_comps, sorter->cs_nr, id,
&comp_sort_ops);
return at < 0 ? NULL :
container_of(sorter->cs_comps[at], struct pool_domain, do_comp);
}
static struct pool_target *
comp_sorter_find_target(struct pool_comp_sorter *sorter, unsigned int id)
{
int at;
D_ASSERT(sorter->cs_type == PO_COMP_TP_TARGET);
at = daos_array_find(sorter->cs_comps, sorter->cs_nr, id,
&comp_sort_ops);
return at < 0 ? NULL :
container_of(sorter->cs_comps[at], struct pool_target, ta_comp);
}
static int
comp_sorter_sort(struct pool_comp_sorter *sorter)
{
return daos_array_sort(sorter->cs_comps, sorter->cs_nr, true,
&comp_sort_ops);
}
/** create a new pool buffer which can store \a nr components */
struct pool_buf *
pool_buf_alloc(unsigned int nr)
{
struct pool_buf *buf;
D_ALLOC(buf, pool_buf_size(nr));
if (buf != NULL) {
buf->pb_nr = nr;
buf->pb_version = POOL_MAP_VERSION;
}
return buf;
}
/** duplicate a new pool buffer, will internally allocate memory */
struct pool_buf *
pool_buf_dup(struct pool_buf *buf)
{
struct pool_buf *buf_alloc;
D_ASSERT(buf != NULL);
buf_alloc = pool_buf_alloc(buf->pb_nr);
if (buf_alloc == NULL)
return NULL;
memcpy(buf_alloc, buf, pool_buf_size(buf->pb_nr));
return buf_alloc;
}
/** free the pool buffer */
void
pool_buf_free(struct pool_buf *buf)
{
D_FREE(buf);
}
/**
* Add an array of components to the pool buffer.
* The caller should always attach domains before targets, and attach high
* level domains before low level domains.
*
* TODO: add more description about pool map format.
*/
int
pool_buf_attach(struct pool_buf *buf, struct pool_component *comps,
unsigned int comp_nr)
{
unsigned int nr = buf->pb_domain_nr + buf->pb_node_nr +
buf->pb_target_nr;
if (buf->pb_nr < nr + comp_nr)
return -DER_NOSPACE;
D_DEBUG(DB_TRACE, "Attaching %d components\n", comp_nr);
for (; comp_nr > 0; comp_nr--, comps++, nr++) {
struct pool_component *prev;
prev = nr == 0 ? NULL : &buf->pb_comps[nr - 1];
if (prev != NULL && prev->co_type < comps[0].co_type) {
D_ERROR("bad type hierarchy, prev type=%d, "
"current=%d\n", prev->co_type,
comps[0].co_type);
return -DER_INVAL;
}
if (comps[0].co_type == PO_COMP_TP_TARGET)
buf->pb_target_nr++;
else if (comps[0].co_type == PO_COMP_TP_RANK)
buf->pb_node_nr++;
else
buf->pb_domain_nr++;
buf->pb_comps[nr] = comps[0];
D_DEBUG(DB_TRACE, "nr %d %s\n", nr,
pool_comp_type2str(comps[0].co_type));
}
return 0;
}
int
pool_buf_pack(struct pool_buf *buf)
{
if (buf->pb_nr != buf->pb_target_nr + buf->pb_domain_nr +
buf->pb_node_nr)
return -DER_INVAL;
/* TODO: checksum, swab... */
return 0;
}
int
pool_buf_unpack(struct pool_buf *buf)
{
/* TODO: swab, verify checksum */
return 0;
}
/**
* Parse pool buffer and construct domain+target array (tree) based on
* the information in pool buffer.
*
* \param buf [IN] pool buffer to be parsed
* \param tree_pp [OUT] the returned domain+target tree.
*/
static int
pool_buf_parse(struct pool_buf *buf, struct pool_domain **tree_pp)
{
struct pool_domain *tree;
struct pool_domain *domain;
struct pool_domain *parent;
struct pool_target *targets;
pool_comp_type_t type;
int size;
int i;
int rc = 0;
if (buf->pb_target_nr == 0 || buf->pb_node_nr == 0 ||
buf->pb_domain_nr + buf->pb_node_nr + buf->pb_target_nr !=
buf->pb_nr) {
D_DEBUG(DB_MGMT, "Invalid number of components: %d/%d/%d/%d\n",
buf->pb_nr, buf->pb_domain_nr, buf->pb_node_nr,
buf->pb_target_nr);
return -DER_INVAL;
}
size = sizeof(struct pool_domain) * (buf->pb_domain_nr + 1) + /* root */
sizeof(struct pool_domain) * (buf->pb_node_nr) +
sizeof(struct pool_target) * (buf->pb_target_nr);
D_DEBUG(DB_TRACE, "domain %d node %d target %d\n", buf->pb_domain_nr,
buf->pb_node_nr, buf->pb_target_nr);
D_ALLOC(tree, size);
if (tree == NULL)
return -DER_NOMEM;
targets = (struct pool_target *)&tree[buf->pb_domain_nr +
buf->pb_node_nr + 1];
for (i = 0; i < buf->pb_target_nr; i++)
targets[i].ta_comp = buf->pb_comps[buf->pb_domain_nr +
buf->pb_node_nr + i];
/* Initialize the root */
parent = &tree[0]; /* root */
parent->do_comp.co_type = PO_COMP_TP_ROOT;
parent->do_comp.co_status = PO_COMP_ST_UPIN;
if (buf->pb_domain_nr == 0) {
/* nodes are directly attached under the root */
parent->do_target_nr = buf->pb_node_nr;
parent->do_child_nr = buf->pb_node_nr;
} else {
parent->do_child_nr = buf->pb_domain_nr;
}
parent->do_children = &tree[1];
parent++;
type = buf->pb_comps[0].co_type;
for (i = 1;; i++) {
struct pool_component *comp = &tree[i].do_comp;
int nr = 0;
*comp = buf->pb_comps[i - 1];
if (comp->co_type >= PO_COMP_TP_ROOT) {
D_ERROR("Invalid type %d/%d\n", type, comp->co_type);
rc = -DER_INVAL;
goto out;
}
D_DEBUG(DB_TRACE, "Parse %s[%d] i %d nr %d\n",
pool_comp_type2str(comp->co_type), comp->co_id,
i, comp->co_nr);
if (comp->co_type == type)
continue;
type = comp->co_type;
for (; parent < &tree[i]; parent++) {
if (type != PO_COMP_TP_TARGET) {
D_DEBUG(DB_TRACE, "Setup children for %s[%d]"
" child nr %d\n",
pool_domain_name(parent),
parent->do_comp.co_id,
parent->do_child_nr);
parent->do_children = &tree[i + nr];
nr += parent->do_child_nr;
} else {
/* parent is the last level domain */
D_DEBUG(DB_TRACE, "Setup targets for %s[%d]\n",
pool_domain_name(parent),
parent->do_comp.co_id);
parent->do_target_nr = parent->do_comp.co_nr;
parent->do_comp.co_nr = 0;
parent->do_targets = targets;
targets += parent->do_target_nr;
D_DEBUG(DB_TRACE, "%s[%d] has %d targets\n",
pool_domain_name(parent),
parent->do_comp.co_id,
parent->do_target_nr);
}
}
if (type == PO_COMP_TP_TARGET)
break;
}
D_DEBUG(DB_TRACE, "Build children and targets pointers\n");
for (domain = &tree[0]; domain->do_targets == NULL;
domain = &tree[0]) {
while (domain->do_targets == NULL) {
parent = domain;
D_ASSERTF(domain->do_children != NULL,
"%s[%d]: %d/%d\n",
pool_domain_name(domain),
domain->do_comp.co_id,
domain->do_child_nr, domain->do_target_nr);
domain = &domain->do_children[0];
}
type = parent->do_comp.co_type;
for (; parent->do_comp.co_type == type; parent++) {
parent->do_targets = domain->do_targets;
for (i = 0; i < parent->do_child_nr; i++, domain++)
parent->do_target_nr += domain->do_target_nr;
D_DEBUG(DB_TRACE, "Set %d target for %s[%d]\n",
parent->do_target_nr,
pool_comp_type2str(parent->do_comp.co_type),
parent->do_comp.co_id);
}
}
out:
if (rc)
D_FREE(tree);
else
*tree_pp = tree;
return rc;
}
/**
* Extract pool buffer from a pool map.
*
* \param map [IN] The pool map to extract from.
* \param buf_pp [OUT] The returned pool buffer, should be freed
* by pool_buf_free.
*/
int
pool_buf_extract(struct pool_map *map, struct pool_buf **buf_pp)
{
struct pool_buf *buf;
struct pool_domain *tree;
struct pool_comp_cntr cntr;
unsigned int dom_nr;
int i;
int rc;
D_ASSERT(map->po_tree != NULL);
tree = &map->po_tree[1]; /* skip the root */
pool_tree_count(tree, &cntr);
if (cntr.cc_domains + cntr.cc_targets == 0) {
D_DEBUG(DB_MGMT, "Empty pool map.\n");
return -DER_NONEXIST;
}
buf = pool_buf_alloc(cntr.cc_domains + cntr.cc_targets);
if (buf == NULL)
return -DER_NOMEM;
for (dom_nr = cntr.cc_top_doms; dom_nr != 0;
tree = tree[0].do_children) {
int child_nr;
for (i = child_nr = 0; i < dom_nr; i++) {
struct pool_component comp;
comp = tree[i].do_comp;
if (tree[i].do_children != NULL) {
/* intermediate domain */
child_nr += tree[i].do_child_nr;
} else {
/* the last level domain */
comp.co_nr = tree[i].do_target_nr;
}
pool_buf_attach(buf, &comp, 1);
}
dom_nr = child_nr;
}
tree = &map->po_tree[0];
for (i = 0; i < cntr.cc_targets; i++)
pool_buf_attach(buf, &tree->do_targets[i].ta_comp, 1);
if (buf->pb_nr != buf->pb_target_nr + buf->pb_domain_nr +
buf->pb_node_nr) {
D_DEBUG(DB_MGMT, "Invalid pool map format.\n");
D_GOTO(failed, rc = -DER_INVAL);
}
*buf_pp = buf;
return 0;
failed:
pool_buf_free(buf);
return rc;
}
/**
* Count number of domains, targets, and layers of domains etc in the
* component tree.
*/
static void
pool_tree_count(struct pool_domain *tree, struct pool_comp_cntr *cntr)
{
unsigned int dom_nr;
if (tree[0].do_children != NULL) {
dom_nr = tree[0].do_children - tree;
} else {
D_ASSERT(tree[0].do_targets != NULL);
dom_nr = (struct pool_domain *)tree[0].do_targets - tree;
}
cntr->cc_top_doms = dom_nr;
cntr->cc_domains = dom_nr;
cntr->cc_targets = 0;
cntr->cc_layers = 0;
for (; tree != NULL; tree = tree[0].do_children, cntr->cc_layers++) {
int child_nr;
int i;
D_DEBUG(DB_TRACE, "%s, nr = %d\n", pool_domain_name(&tree[0]),
dom_nr);
for (i = child_nr = 0; i < dom_nr; i++) {
if (tree[i].do_children != NULL) {
cntr->cc_domains += tree[i].do_child_nr;
child_nr += tree[i].do_child_nr;
} else {
cntr->cc_targets += tree[i].do_target_nr;
}
}
dom_nr = child_nr;
}
}
int
pool_map_comp_cnt(struct pool_map *map)
{
struct pool_comp_cntr cntr = {0};
D_ASSERT(map->po_tree != NULL);
pool_tree_count(&map->po_tree[1], &cntr);
return cntr.cc_domains + cntr.cc_targets;
}
/**
* Calculate memory size of the component tree.
*/
static unsigned int
pool_tree_size(struct pool_domain *tree)
{
struct pool_comp_cntr cntr;
pool_tree_count(tree, &cntr);
return sizeof(struct pool_target) * cntr.cc_targets +
sizeof(struct pool_domain) * cntr.cc_domains;
}
/**
* Rebuild pointers for the component tree
*/
static void
pool_tree_build_ptrs(struct pool_domain *tree, struct pool_comp_cntr *cntr)
{
struct pool_target *targets;
int dom_nr;
D_DEBUG(DB_TRACE, "Layers %d, top domains %d, domains %d, targets %d\n",
cntr->cc_layers, cntr->cc_top_doms, cntr->cc_domains,
cntr->cc_targets);
targets = (struct pool_target *)&tree[cntr->cc_domains];
for (dom_nr = cntr->cc_top_doms; tree != NULL;
tree = tree[0].do_children) {
struct pool_domain *children = &tree[dom_nr];
struct pool_target *tgs = targets;
int child_nr = 0;
int i;
for (i = 0; i < dom_nr; i++) {
if (tree[i].do_children != NULL) {
tree[i].do_children = children;
child_nr += tree[i].do_child_nr;
children += tree[i].do_child_nr;
}
tree[i].do_targets = tgs;
tgs += tree[i].do_target_nr;
}
dom_nr = child_nr;
}
}
/** Free the component tree */
static void
pool_tree_free(struct pool_domain *tree)
{
D_FREE(tree);
}
/** Check if component buffer is sane */
static bool
pool_tree_sane(struct pool_domain *tree, uint32_t version)
{
struct pool_domain *parent = NULL;
struct pool_target *targets = tree[0].do_targets;
struct pool_comp_cntr cntr;
int dom_nr;
int i;
D_DEBUG(DB_TRACE, "Sanity check of component buffer\n");
pool_tree_count(tree, &cntr);
if (cntr.cc_targets == 0) {
D_ERROR("Buffer has no target\n");
return false;
}
for (dom_nr = cntr.cc_top_doms; tree != NULL;
tree = tree[0].do_children) {
struct pool_domain *prev = &tree[0];
int child_nr = 0;
if (parent != NULL &&
parent->do_comp.co_type <= tree[0].do_comp.co_type) {
D_ERROR("Type of parent domain %d(%s) should be "
"greater than child domain %d(%s)\n",
parent->do_comp.co_type,
pool_domain_name(parent),
tree[0].do_comp.co_type,
pool_domain_name(&tree[0]));
return false;
}
for (i = 0; i < dom_nr; i++) {
if (tree[i].do_comp.co_ver > version) {
D_ERROR("Invalid version %u/%u\n",
tree[i].do_comp.co_ver, version);
return false;
}
if (prev->do_comp.co_type != tree[i].do_comp.co_type) {
D_ERROR("Unmatched domain type %d/%d\n",
tree[i].do_comp.co_type,
prev->do_comp.co_type);
return false;
}
if (tree[i].do_targets == NULL ||
tree[i].do_target_nr == 0) {
D_ERROR("No target found\n");
return false; /* always has targets */
}
if ((prev->do_children == NULL) ^
(tree[i].do_children == NULL)) {
D_ERROR("Invalid child tree\n");
return false;
}
if ((prev->do_targets == NULL) ^
(tree[i].do_targets == NULL)) {
D_ERROR("Invalid target tree\n");
return false;
}
if (prev != &tree[i] &&
prev->do_children != NULL &&
prev->do_children + prev->do_child_nr !=
tree[i].do_children) {
D_ERROR("Invalid children pointer\n");
return false;
}
if (prev != &tree[i] &&
prev->do_targets != NULL &&
prev->do_targets + prev->do_target_nr !=
tree[i].do_targets) {
D_ERROR("Invalid children pointer i"
" %d target nr %d\n", i,
prev->do_target_nr);
return false;
}
if (tree[i].do_child_nr != 0)
child_nr += tree[i].do_child_nr;
prev = &tree[i];
}
parent = &tree[0];
dom_nr = child_nr;
}
for (i = 0; i < cntr.cc_targets; i++) {
if (targets[i].ta_comp.co_type != PO_COMP_TP_TARGET) {
D_ERROR("Invalid leaf type %d(%s) i %d\n",
targets[i].ta_comp.co_type,
pool_comp_name(&targets[i].ta_comp), i);
return false;
}
if (targets[i].ta_comp.co_ver > version) {
D_ERROR("Invalid version %u/%u i %d\n",
targets[i].ta_comp.co_ver, version, i);
return false;
}
}
D_DEBUG(DB_TRACE, "Component buffer is sane\n");
return true;
}
/** copy a components tree */
static void
pool_tree_copy(struct pool_domain *dst, struct pool_domain *src)
{
struct pool_comp_cntr cntr;
memcpy(dst, src, pool_tree_size(src));
pool_tree_count(src, &cntr);
pool_tree_build_ptrs(dst, &cntr);
}
/** free data members of a pool map */
static void
pool_map_finalise(struct pool_map *map)
{
int i;
D_DEBUG(DB_TRACE, "Release buffers for pool map\n");
comp_sorter_fini(&map->po_target_sorter);
if (map->po_comp_fail_cnts != NULL)
D_FREE(map->po_comp_fail_cnts);
if (map->po_domain_sorters != NULL) {
D_ASSERT(map->po_domain_layers != 0);
for (i = 0; i < map->po_domain_layers; i++)
comp_sorter_fini(&map->po_domain_sorters[i]);
D_FREE(map->po_domain_sorters);
map->po_domain_layers = 0;
}
if (map->po_tree != NULL) {
pool_tree_free(map->po_tree);
map->po_tree = NULL;
}
D_MUTEX_DESTROY(&map->po_lock);
}
/**
* Install a component tree to a pool map.
*
* \param map [IN] The pool map to be initialized.
* \param tree [IN] Component tree for the pool map.
*/
static int
pool_map_initialise(struct pool_map *map, struct pool_domain *tree)
{
struct pool_comp_cntr cntr;
int i;
int rc = 0;
D_ASSERT(pool_map_empty(map));
map->po_tree = tree; /* should be free in case of error */
if (tree[0].do_comp.co_type != PO_COMP_TP_ROOT) {
D_DEBUG(DB_TRACE, "Invalid tree format: %s/%d\n",
pool_domain_name(&tree[0]), tree[0].do_comp.co_type);
rc = -DER_INVAL;
goto out_tree;
}
rc = D_MUTEX_INIT(&map->po_lock, NULL);
if (rc != 0)
goto out_tree;
pool_tree_count(tree, &cntr);
/* po_map_print(map); */
D_DEBUG(DB_TRACE, "Setup nlayers %d, ndomains %d, ntargets %d\n",
cntr.cc_layers, cntr.cc_domains, cntr.cc_targets);
map->po_domain_layers = cntr.cc_layers;
D_ASSERT(map->po_domain_layers != 0);
D_ALLOC_ARRAY(map->po_comp_fail_cnts, map->po_domain_layers);
if (map->po_comp_fail_cnts == NULL) {
rc = -DER_NOMEM;
goto out_mutex;
}
D_ALLOC_ARRAY(map->po_domain_sorters, map->po_domain_layers);
if (map->po_domain_sorters == NULL) {
rc = -DER_NOMEM;
goto out_comp_fail_cnts;
}
/* pointer arrays for binary search of domains */
for (i = 0; i < map->po_domain_layers; i++) {
struct pool_comp_sorter *sorter = &map->po_domain_sorters[i];
unsigned int j;
D_ASSERT(tree[0].do_comp.co_type != PO_COMP_TP_TARGET);
pool_tree_count(tree, &cntr);
rc = comp_sorter_init(sorter, cntr.cc_top_doms,
tree[0].do_comp.co_type);
if (rc != 0)
goto out_domain_sorters;
D_DEBUG(DB_TRACE, "domain %s, ndomains %d\n",
pool_domain_name(&tree[0]), sorter->cs_nr);
for (j = 0; j < sorter->cs_nr; j++)
sorter->cs_comps[j] = &tree[j].do_comp;
rc = comp_sorter_sort(sorter);
if (rc != 0)
goto out_domain_sorters;
tree = &tree[sorter->cs_nr];
}
rc = comp_sorter_init(&map->po_target_sorter, cntr.cc_targets,
PO_COMP_TP_TARGET);
if (rc != 0)
goto out_domain_sorters;
for (i = 0; i < cntr.cc_targets; i++) {
struct pool_target *ta;
ta = &map->po_tree->do_targets[i];
map->po_target_sorter.cs_comps[i] = &ta->ta_comp;
}
rc = comp_sorter_sort(&map->po_target_sorter);
if (rc != 0)
goto out_target_sorter;
return 0;
out_target_sorter:
comp_sorter_fini(&map->po_target_sorter);
out_domain_sorters:
for (i = 0; i < map->po_domain_layers; i++)
comp_sorter_fini(&map->po_domain_sorters[i]);
D_FREE(map->po_domain_sorters);
out_comp_fail_cnts:
D_FREE(map->po_comp_fail_cnts);
out_mutex:
map->po_domain_layers = 0;
D_MUTEX_DESTROY(&map->po_lock);
out_tree:
pool_tree_free(map->po_tree);
map->po_tree = NULL;
D_DEBUG(DB_MGMT, "Failed to setup pool map: "DF_RC"\n", DP_RC(rc));
return rc;
}
/**
* Check if a component tree is compatible with a pool map, it returns 0
* if components in \a tree can be merged into \a map, otherwise returns
* error code.
*/
static int
pool_map_compat(struct pool_map *map, uint32_t version,
struct pool_domain *tree)
{
struct pool_domain *parent;
struct pool_domain *doms;
int dom_nr;
int rc;
if (pool_map_empty(map)) {
D_DEBUG(DB_MGMT, "empty map, type of buffer root is %s\n",
pool_domain_name(&tree[0]));
return 0;
}
if (map->po_version >= version)
return -DER_NO_PERM;
/* pool_buf_parse should always generate root */
if (tree[0].do_comp.co_type != PO_COMP_TP_ROOT) {
D_ERROR("first component (type=%d) is not root\n",
tree[0].do_comp.co_type);
return -DER_INVAL;
}
rc = pool_map_find_domain(map, tree[1].do_comp.co_type,
PO_COMP_ID_ALL, &doms);
if (rc == 0) {
D_ERROR("failed to find existing domains\n");
return -DER_INVAL;
}
if (doms - map->po_tree == 1) {
/* the first component is indeed under the root */
parent = &tree[0];
} else {
/* root of the new tree is dummy */
parent = NULL;
}
D_DEBUG(DB_TRACE, "Check if buffer is compatible with pool map\n");
dom_nr = tree[0].do_child_nr;
for (tree++; tree != NULL; parent = &tree[0],
tree = tree[0].do_children,
doms = doms[0].do_children) {
int child_nr = 0;
int nr = 0;
int i;
int j;
if (doms == NULL) {
D_ERROR("tree has more layers than the map\n");
return -DER_INVAL;
}
D_DEBUG(DB_TRACE, "checking %s/%s\n",
pool_domain_name(&tree[0]), pool_domain_name(&doms[0]));
for (i = 0; i < dom_nr; i++) {
struct pool_component *dc = &tree[i].do_comp;
bool existed;
if (dc->co_type != doms[0].do_comp.co_type) {
D_ERROR("domain type not match %s(%u) %s(%u)\n",
pool_comp_name(dc), dc->co_type,
pool_domain_name(&doms[0]),
doms[0].do_comp.co_type);
return -DER_INVAL;
}
existed = domain_exist(map, dc->co_type, dc->co_id);
if (dc->co_status == PO_COMP_ST_NEW) {
if (parent == NULL) {
D_ERROR("null parent not valid for "
"new comp\n");
return -DER_INVAL;
}
if (existed) {
D_ERROR("new component ID %d already "
"exists\n", dc->co_id);
return -DER_NO_PERM;
}
} else if (dc->co_status == PO_COMP_ST_UPIN) {
if (!existed) {
D_ERROR("status [UPIN] not valid for "
"new comp\n");
return -DER_INVAL;
}
D_ASSERT(parent != NULL);
if (parent->do_comp.co_status ==
PO_COMP_ST_NEW) {
D_ERROR("invalid parent status [NEW] "
"when component status "
"[UPIN]\n");
return -DER_INVAL;
}
} else {
D_ERROR("bad comp status=0x%x\n",
dc->co_status);
return -DER_INVAL;
}
if (tree[i].do_children != NULL) {
child_nr += tree[i].do_child_nr;
} else {
/* the last layer domain */
if (doms[0].do_children != NULL) {
D_ERROR("unmatched tree\n");
return -DER_INVAL;
}
for (j = 0; j < tree[i].do_target_nr; j++) {
struct pool_component *tc;
tc = &tree[i].do_targets[j].ta_comp;
if (tc->co_status != PO_COMP_ST_NEW ||
target_exist(map, tc->co_id)) {
D_ERROR("invalid component "
"status\n");
return -DER_INVAL;
}
}
}
nr++;
D_ASSERT(parent != NULL);
if (parent->do_child_nr == nr) {
parent++;
nr = 0;
}
}
dom_nr = child_nr;
}
return 0;
}
/**
* Merge all new components from \a tree into \a map.
* Already existent components will be ignored.
*/
static int
pool_map_merge(struct pool_map *map, uint32_t version,
struct pool_domain *tree)
{
struct pool_map *src_map;
struct pool_domain *dst_tree;
struct pool_domain *dst_doms;
struct pool_domain *cur_doms;
void *addr;
struct pool_comp_cntr cntr;
unsigned int dom_nr;
unsigned int size;
int i;
int rc;
/* create scratch map for merging */
D_ALLOC_PTR(src_map);
if (src_map == NULL) {
pool_tree_free(tree);
return -DER_NOMEM;
}
rc = pool_map_initialise(src_map, tree);
if (rc != 0) {
D_DEBUG(DB_MGMT, "Failed to create scratch map for buffer: "
DF_RC"\n", DP_RC(rc));
/* pool_tree_free(tree) did in pool_map_initialise */
D_FREE(src_map);
return rc;
}
/* destination buffer could has larger than the actually needed space,
* but it is not big deal.
*/
size = pool_tree_size(map->po_tree) + pool_tree_size(tree);
D_ALLOC(dst_tree, size);
if (dst_tree == NULL) {
rc = -DER_NOMEM;
goto failed;
}
/* copy current pool map to destination buffer */
pool_tree_copy(dst_tree, map->po_tree);
if (src_map->po_domain_layers != map->po_domain_layers) {
/* source map may have less levels because it could be in
* a subtree, skip the fake root in this case.
*/
D_ASSERT(src_map->po_domain_layers < map->po_domain_layers);
rc = pool_map_find_domain(map, tree[1].do_comp.co_type,
PO_COMP_ID_ALL, &cur_doms);
} else {
rc = pool_map_find_domain(map, tree[0].do_comp.co_type,
PO_COMP_ID_ALL, &cur_doms);
}
if (rc == 0) {
D_FREE(dst_tree);
goto failed;
}
dst_doms = dst_tree;
dst_doms += cur_doms - map->po_tree;
pool_tree_count(dst_doms, &cntr);
dom_nr = cntr.cc_top_doms;
/* overwrite the components after the top layer domains */
addr = (void *)&dst_doms[dom_nr];
pool_tree_count(dst_tree, &cntr);
/* complex buffer manipulating... */
for (; dst_doms != NULL;
dst_doms = dst_doms[0].do_children,
cur_doms = cur_doms[0].do_children) {
struct pool_domain *cdom = &cur_doms[0];
int child_nr = 0;
for (i = 0; i < dom_nr; i++) {
struct pool_domain *ddom = &dst_doms[i];
struct pool_domain *sdom;
int nb;
int j;
if (ddom->do_comp.co_ver == version) {
ddom->do_children = NULL;
ddom->do_targets = NULL;
ddom->do_child_nr = 0;
ddom->do_target_nr = 0;
D_DEBUG(DB_TRACE, "Add new domain %s %d\n",
pool_domain_name(cdom), dom_nr);
} else {
/* Domain existed, copy its children/targets
* from current pool map.
*/
D_ASSERT(ddom->do_comp.co_ver < version);
D_ASSERT(ddom->do_comp.co_id ==
cdom->do_comp.co_id);
if (cdom->do_children != NULL) {
ddom->do_children = addr;
ddom->do_child_nr = cdom->do_child_nr;
nb = cdom->do_child_nr *
sizeof(struct pool_domain);
memcpy(addr, cdom->do_children, nb);
} else {
ddom->do_targets = addr;
ddom->do_target_nr = cdom->do_target_nr;
nb = cdom->do_target_nr *
sizeof(struct pool_target);
memcpy(addr, cdom->do_targets, nb);
}
addr += nb;
cdom++;
}
D_DEBUG(DB_TRACE, "Check changes for %s[%d]\n",
pool_domain_name(ddom), ddom->do_comp.co_id);
rc = pool_map_find_domain(src_map,
ddom->do_comp.co_type,
ddom->do_comp.co_id, &sdom);
if (rc == 0) {
child_nr += ddom->do_child_nr;
continue; /* no change for this domain */
}
/* new buffer may have changes for this domain */
if (sdom->do_children != NULL) {
struct pool_domain *child = addr;
D_DEBUG(DB_TRACE, "Scan children of %s[%d]\n",
pool_domain_name(ddom),
ddom->do_comp.co_id);
if (ddom->do_children == NULL)
ddom->do_children = child;
/* copy new child domains to dest buffer */
for (j = 0; j < sdom->do_child_nr; j++) {
struct pool_component *dc;
dc = &sdom->do_children[j].do_comp;
/* ignore existent children */
if (dc->co_status != PO_COMP_ST_NEW)
continue;
D_DEBUG(DB_TRACE, "New %s[%d]\n",
pool_comp_type2str(dc->co_type),
dc->co_id);
*child = sdom->do_children[j];
child++;
ddom->do_child_nr++;
cntr.cc_domains++;
}
addr = child;
} else {
struct pool_target *target = addr;
D_DEBUG(DB_TRACE, "Scan targets of %s[%d]\n",
pool_domain_name(ddom),
ddom->do_comp.co_id);
if (ddom->do_targets == NULL)
ddom->do_targets = target;
/* copy new targets to destination buffer */
for (j = 0; j < sdom->do_target_nr; j++) {
struct pool_component *tc;
tc = &sdom->do_targets[j].ta_comp;
if (tc->co_status != PO_COMP_ST_NEW)
continue;
D_DEBUG(DB_TRACE, "New target[%d]\n",
tc->co_id);
*target = sdom->do_targets[j];
target++;
ddom->do_target_nr++;
cntr.cc_targets++;
}
addr = target;
}
child_nr += ddom->do_child_nr;
}
dom_nr = child_nr;
}
D_ASSERT(addr - (void *)dst_tree <= size);
D_DEBUG(DB_TRACE, "Merged all components\n");
/* At this point, I only have valid children pointers for the last
* layer domains, and need to build target pointers for all layers.
*/
pool_tree_build_ptrs(dst_tree, &cntr);
/* release old buffers of pool map */
pool_map_finalise(map);
/* install new buffer for pool map */
rc = pool_map_initialise(map, dst_tree);
if (rc != 0)
/* pool_tree_free(dst_tree) did in pool_map_initialise */
goto failed;
map->po_version = version;
failed:
pool_map_destroy(src_map);
return rc;
}
static int
uuid_compare_cb(const void *a, const void *b)
{
uuid_t *ua = (uuid_t *)a;
uuid_t *ub = (uuid_t *)b;
return uuid_compare(*ua, *ub);
}
static int
add_domains_to_pool_buf(struct pool_map *map, struct pool_buf *map_buf,
int map_version,
int ndomains, const uint32_t *domains)
{
int i = 0;
int rc;
uint32_t num_comps;
uint8_t new_status;
struct d_fd_tree tree = {0};
struct d_fd_node node = {0};
if (map != NULL) {
new_status = PO_COMP_ST_NEW;
num_comps = pool_map_find_domain(map, PO_COMP_TP_NODE,
PO_COMP_ID_ALL, NULL);
} else {
new_status = PO_COMP_ST_UPIN;
num_comps = 0;
}
rc = d_fd_tree_init(&tree, domains, ndomains);
if (rc != 0)
return rc;
/* discard the root - it's being added to the pool buf elsewhere */
rc = d_fd_tree_next(&tree, &node);
while (rc == 0) {
struct pool_component map_comp;
rc = d_fd_tree_next(&tree, &node);
if (rc != 0) {
/* got to the end of the tree with no problems */
if (rc == -DER_NONEXIST)
rc = 0;
break;
}
/* ranks are handled elsewhere for now */
if (node.fdn_type != D_FD_NODE_TYPE_DOMAIN)
break;
/* TODO DAOS-6353: Use the layer number as type */
map_comp.co_type = PO_COMP_TP_NODE;
map_comp.co_status = new_status;
map_comp.co_index = i + num_comps;
map_comp.co_id = node.fdn_val.dom->fd_id;
map_comp.co_rank = 0;
map_comp.co_ver = map_version;
map_comp.co_fseq = 1;
map_comp.co_nr = node.fdn_val.dom->fd_children_nr;
if (map != NULL) {
struct pool_domain *current;
int already_in_map;
already_in_map = pool_map_find_domain(map,
PO_COMP_TP_NODE,
map_comp.co_id,
¤t);
if (already_in_map > 0)
map_comp.co_status = current->do_comp.co_status;
}
rc = pool_buf_attach(map_buf, &map_comp, 1 /* comp_nr */);
if (rc != 0)
D_ERROR("failed attaching domain ID %d to pool "
"buf\n", node.fdn_val.dom->fd_id);
i++;
}
return rc;
}
int
gen_pool_buf(struct pool_map *map, struct pool_buf **map_buf_out,
int map_version, int ndomains, int nnodes, int ntargets,
const uint32_t *domains, uuid_t target_uuids[],
const d_rank_list_t *target_addrs, uuid_t **uuids_out,
uint32_t dss_tgt_nr)
{
struct pool_component map_comp;
struct pool_buf *map_buf;
struct pool_domain *found_dom;
uuid_t *uuids = NULL;
uint32_t num_comps;
uint8_t new_status;
bool updated;
int i, rc;
uint32_t num_domain_comps;
updated = false;
/*
* Estimate number of domains for allocating the pool buffer
*/
rc = d_fd_get_exp_num_domains(ndomains, nnodes, &num_domain_comps);
if (rc != 0) {
D_ERROR("Invalid domain array, len=%u\n", ndomains);
return rc;
}
D_ASSERT(num_domain_comps > 0);
num_domain_comps--; /* remove the root domain - allocated separately */
/* Prepare the pool map attribute buffers. */
map_buf = pool_buf_alloc(num_domain_comps + nnodes + ntargets);
if (map_buf == NULL)
D_GOTO(out_map_buf, rc = -DER_NOMEM);
/* Make a sorted target UUID array to determine target IDs. */
D_ALLOC_ARRAY_NZ(uuids, nnodes);
if (uuids == NULL)
D_GOTO(out_map_buf, rc = -DER_NOMEM);
memcpy(uuids, target_uuids, sizeof(uuid_t) * nnodes);
qsort(uuids, nnodes, sizeof(uuid_t), uuid_compare_cb);
rc = add_domains_to_pool_buf(map, map_buf, map_version, ndomains,
domains);
if (rc != 0)
D_GOTO(out_map_buf, rc);
if (map != NULL) {
new_status = PO_COMP_ST_NEW;
num_comps = pool_map_find_domain(map, PO_COMP_TP_RANK,
PO_COMP_ID_ALL, NULL);
} else {
new_status = PO_COMP_ST_UPIN;
num_comps = 0;
}
/* fill nodes */
for (i = 0; i < nnodes; i++) {
uuid_t *p = bsearch(target_uuids[i], uuids, nnodes,
sizeof(uuid_t), uuid_compare_cb);
if (map) {
found_dom = pool_map_find_node_by_rank(map,
target_addrs->rl_ranks[i]);
if (found_dom)
continue;
}
updated = true;
map_comp.co_type = PO_COMP_TP_RANK;
map_comp.co_status = new_status;
map_comp.co_index = i + num_comps;
map_comp.co_id = (p - uuids) + num_comps;
map_comp.co_rank = target_addrs->rl_ranks[i];
map_comp.co_ver = map_version;
map_comp.co_in_ver = map_version;
map_comp.co_fseq = 1;
map_comp.co_flags = PO_COMPF_NONE;
map_comp.co_nr = dss_tgt_nr;
rc = pool_buf_attach(map_buf, &map_comp, 1 /* comp_nr */);
if (rc != 0) {
D_ERROR("failed to attach to pool buf, "DF_RC"\n",
DP_RC(rc));
D_GOTO(out_map_buf, rc);
}
}
if (!updated)
D_GOTO(out_map_buf, rc = -DER_ALREADY);
if (map != NULL)
num_comps = pool_map_find_target(map, PO_COMP_ID_ALL, NULL);
else
num_comps = 0;
/* fill targets */
for (i = 0; i < nnodes; i++) {
int j;
for (j = 0; j < dss_tgt_nr; j++) {
map_comp.co_type = PO_COMP_TP_TARGET;
map_comp.co_status = new_status;
map_comp.co_index = j;
map_comp.co_id = (i * dss_tgt_nr + j) + num_comps;
map_comp.co_rank = target_addrs->rl_ranks[i];
map_comp.co_ver = map_version;
map_comp.co_in_ver = map_version;
map_comp.co_fseq = 1;
map_comp.co_flags = PO_COMPF_NONE;
map_comp.co_nr = 1;
rc = pool_buf_attach(map_buf, &map_comp, 1);
if (rc != 0)
D_GOTO(out_map_buf, rc);
}
}
if (uuids_out)
*uuids_out = uuids;
else
D_FREE(uuids);
*map_buf_out = map_buf;
return 0;
out_map_buf:
pool_buf_free(map_buf);
D_FREE(uuids);
return rc;
}
int
pool_map_extend(struct pool_map *map, uint32_t version, struct pool_buf *buf)
{
struct pool_domain *tree = NULL;
int rc;
rc = pool_buf_parse(buf, &tree);
if (rc != 0)
return rc;
if (!pool_tree_sane(tree, version)) {
D_DEBUG(DB_MGMT, "Insane buffer format\n");
rc = -DER_INVAL;
goto error_tree;
}
rc = pool_map_compat(map, version, tree);
if (rc != 0) {
D_DEBUG(DB_MGMT, "Buffer is incompatible with pool map\n");
goto error_tree;
}
D_DEBUG(DB_TRACE, "Merge buffer with already existent pool map\n");
rc = pool_map_merge(map, version, tree);
/* pool_tree_free(tree) did in pool_map_initialise in case of error */
return rc;
error_tree:
pool_tree_free(tree);
return rc;
}
/**
* Create a pool map from components stored in \a buf.
*
* \param buf [IN] The buffer to input pool components.
* \param version [IN] Version for the new created pool map.
* \param mapp [OUT] The returned pool map.
*/
int
pool_map_create(struct pool_buf *buf, uint32_t version, struct pool_map **mapp)
{
struct pool_domain *tree = NULL;
struct pool_map *map;
int rc;
rc = pool_buf_parse(buf, &tree);
if (rc != 0) {
D_ERROR("pool_buf_parse failed: "DF_RC"\n", DP_RC(rc));
return rc;
}
if (!pool_tree_sane(tree, version)) {
pool_tree_free(tree);
return -DER_INVAL;
}
D_ALLOC_PTR(map);
if (map == NULL) {
pool_tree_free(tree);
return -DER_NOMEM;
}
rc = pool_map_initialise(map, tree);
if (rc != 0) {
D_ERROR("pool_map_initialise failed: "DF_RC"\n", DP_RC(rc));
/* pool_tree_free(tree) did in pool_map_initialise() */
goto out;
}
/** Record the initial failed domain counts */
rc = pool_map_update_failed_cnt(map);
if (rc != 0) {
D_ERROR("could not update number of failed targets: "DF_RC"\n",
DP_RC(rc));
pool_map_finalise(map);
goto out;
}
map->po_version = version;
map->po_ref = 1; /* 1 for caller */
out:
if (rc != 0)
D_FREE(map);
else
*mapp = map;
return rc;
}
/**
* Destroy a pool map.
*/
static void
pool_map_destroy(struct pool_map *map)
{
pool_map_finalise(map);
D_FREE(map);
}
/** Take a refcount on a pool map */
void
pool_map_addref(struct pool_map *map)
{
D_MUTEX_LOCK(&map->po_lock);
map->po_ref++;
D_MUTEX_UNLOCK(&map->po_lock);
}
/**
* Release refcount on a pool map, this pool map will be destroyed if it
* is the last refcount
*/
void
pool_map_decref(struct pool_map *map)
{
bool free;
D_MUTEX_LOCK(&map->po_lock);
D_ASSERT(map->po_ref > 0);
map->po_ref--;
free = (map->po_ref == 0);
D_MUTEX_UNLOCK(&map->po_lock);
if (free)
pool_map_destroy(map);
}
/**
* Find a domain whose type equals to \a type and id equals to \a id.
* If id is PO_COMP_ID_ALL, it returns the first element of the contiguously
* stored domain array to \a domain_pp.
*
* The return value of this function is the number of domains, so it is zero
* on failure, and it is always one if a particular id is found.
*/
int
pool_map_find_domain(struct pool_map *map, pool_comp_type_t type, uint32_t id,
struct pool_domain **domain_pp)
{
struct pool_comp_sorter *sorter;
struct pool_domain *tmp;
int i;
if (pool_map_empty(map)) {
D_ERROR("Uninitialized pool map\n");
return 0;
}
D_ASSERT(map->po_domain_layers > 0);
/* all other domains under root are stored in contiguous buffer */
for (tmp = map->po_tree, i = 0; tmp != NULL;
tmp = tmp->do_children, i++) {
if (tmp[0].do_comp.co_type == type)
break;
}
D_ASSERT(i <= map->po_domain_layers);
if (i == map->po_domain_layers) {
D_DEBUG(DB_MGMT, "Can't find domain type %s(%d)\n",
pool_comp_type2str(type), type);
return 0;
}
sorter = &map->po_domain_sorters[i];
D_ASSERT(sorter->cs_type == type);
if (id == PO_COMP_ID_ALL) {
if (domain_pp != NULL)
*domain_pp = tmp;
return sorter->cs_nr;
}
tmp = comp_sorter_find_domain(sorter, id);
if (tmp == NULL)
return 0;
if (domain_pp != NULL)
*domain_pp = tmp;
return 1;
}
/**
* Find all nodes in the pool map.
*
* \param map [IN] pool map to search.
* \param id [IN] id to search.
* \param domain_pp [OUT] returned node domain address.
*
* \return number of the node domains.
* 0 if none.
*/
int
pool_map_find_nodes(struct pool_map *map, uint32_t id,
struct pool_domain **domain_pp)
{
return pool_map_find_domain(map, PO_COMP_TP_RANK, id,
domain_pp);
}
/**
* Find a target whose id equals to \a id by the binary search.
* If id is PO_COMP_ID_ALL, it returns the contiguously stored target array
* to \a target_pp.
*
* The return value of this function is the number of targets, so it is zero
* on failure, and it is always one if a particular id is found.
*
* \param map [IN] The pool map to search
* \param id [IN] Target ID to search
* \param target_pp [OUT] Returned target address
*/
int
pool_map_find_target(struct pool_map *map, uint32_t id,
struct pool_target **target_pp)
{
struct pool_comp_sorter *sorter = &map->po_target_sorter;
struct pool_target *target;
if (pool_map_empty(map)) {
D_ERROR("Uninitialized pool map\n");
return 0;
}
if (id == PO_COMP_ID_ALL) {
if (target_pp != NULL)
*target_pp = map->po_tree[0].do_targets;
return map->po_tree[0].do_target_nr;
}
target = comp_sorter_find_target(sorter, id);
if (target == NULL)
return 0;
if (target_pp != NULL)
*target_pp = target;
return 1;
}
/**
* Find pool domain node by rank in the pool map.
* \params [IN] map pool map to find the node by rank.
* \params [IN] rank rank to use to search the pool domain.
*
* \return domain found by rank.
*/
struct pool_domain *
pool_map_find_node_by_rank(struct pool_map *map, uint32_t rank)
{
struct pool_domain *doms;
struct pool_domain *found = NULL;
int doms_cnt;
int i;
doms_cnt = pool_map_find_nodes(map, PO_COMP_ID_ALL, &doms);
if (doms_cnt <= 0)
return NULL;
for (i = 0; i < doms_cnt; i++) {
/* FIXME add rank sorter to the pool map */
if (doms[i].do_comp.co_rank == rank) {
found = &doms[i];
break;
}
}
return found;
}
/**
* Find all targets belonging to a given list of ranks
*
* \param map [IN] pool map to find the target.
* \param rank_list [IN] rank to be used to find target.
* \param tgts [OUT] found targets.
*
* \return number of targets.
* negative errno if failed.
* Caller is responsible for pool_target_id_list_free
*/
int
pool_map_find_targets_on_ranks(struct pool_map *map, d_rank_list_t *rank_list,
struct pool_target_id_list *tgts)
{
uint32_t count = 0;
uint32_t i;
uint32_t j;
int rc;
tgts->pti_ids = NULL;
tgts->pti_number = 0;
for (i = 0; i < rank_list->rl_nr; i++) {
struct pool_domain *dom;
dom = pool_map_find_node_by_rank(map, rank_list->rl_ranks[i]);
if (dom == NULL) {
pool_target_id_list_free(tgts);
return 0;
}
for (j = 0; j < dom->do_target_nr; j++) {
struct pool_target_id id = {0};
id.pti_id = dom->do_targets[j].ta_comp.co_id;
rc = pool_target_id_list_append(tgts, &id);
if (rc != 0) {
pool_target_id_list_free(tgts);
return 0;
}
count++;
}
}
return count;
}
/**
* Find the target by rank & idx.
*
* \param map [IN] pool map to find the target.
* \param rank [IN] rank to be used to find target.
* \param tgt_idx [IN] tgt_idx to be used to find target.
* \param tgts [OUT] targets found by rank/tgt_idx.
*
* \return number of targets.
* negative errno if failed.
*/
int
pool_map_find_target_by_rank_idx(struct pool_map *map, uint32_t rank,
uint32_t tgt_idx, struct pool_target **tgts)
{
struct pool_domain *dom;
dom = pool_map_find_node_by_rank(map, rank);
if (dom == NULL)
return 0;
if (tgt_idx == -1) {
*tgts = dom->do_targets;
return dom->do_target_nr;
}
if (tgt_idx >= dom->do_target_nr)
return 0;
*tgts = &dom->do_targets[tgt_idx];
return 1;
}
static int
activate_new_target(struct pool_domain *domain, uint32_t id)
{
int i;
D_ASSERT(domain->do_targets != NULL);
/*
* If this component has children, recurse over them.
*
* If the target ID is found in any of the children, activate
* this component and abort the search
*/
if (domain->do_children != NULL) {
for (i = 0; i < domain->do_child_nr; i++) {
int found = activate_new_target(&domain->do_children[i],
id);
if (found) {
domain->do_comp.co_status = PO_COMP_ST_UPIN;
return found;
}
}
}
/*
* Check the targets in this domain to see if they match
*
* If they do, activate them and activate the current domain
*/
for (i = 0; i < domain->do_target_nr; i++) {
struct pool_component *comp = &domain->do_targets[i].ta_comp;
if (comp->co_id == id && (comp->co_status == PO_COMP_ST_NEW ||
comp->co_status == PO_COMP_ST_UP)) {
comp->co_status = PO_COMP_ST_UPIN;
domain->do_comp.co_status = PO_COMP_ST_UPIN;
return 1;
}
}
return 0;
}
/**
* Activate (move to UPIN) a NEW or UP target and all of its parent domains
*
* \param map [IN] The pool map to search
* \param id [IN] Target ID to search
*
* \return 0 if target was not found or not in NEW state
* 1 if target was found and activated
*/
int
pool_map_activate_new_target(struct pool_map *map, uint32_t id)
{
if (map->po_tree != NULL)
return activate_new_target(map->po_tree, id);
return 0;
}
/**
* Check if all targets under one node matching the status.
* \params [IN] dom node domain to be checked.
* \param [IN] status status to be checked.
*
* \return true if matches, otherwise false.
*/
bool
pool_map_node_status_match(struct pool_domain *dom, unsigned int status)
{
int i;
for (i = 0; i < dom->do_target_nr; i++) {
if (!(dom->do_targets[i].ta_comp.co_status & status))
return false;
}
return true;
}
static void
fseq_sort_op_swap(void *array, int a, int b)
{
struct pool_component *comps = (struct pool_component *)array;
struct pool_component tmp;
tmp = comps[a];
comps[a] = comps[b];
comps[b] = tmp;
}
static int
fseq_sort_op_cmp(void *array, int a, int b)
{
struct pool_component *comps = (struct pool_component *)array;
if (comps[a].co_fseq > comps[b].co_fseq)
return 1;
if (comps[a].co_fseq < comps[b].co_fseq)
return -1;
return 0;
}
static int
fseq_sort_op_cmp_key(void *array, int i, uint64_t key)
{
struct pool_component *comps = (struct pool_component *)array;
uint32_t fseq = (uint32_t)key;
if (comps[i].co_fseq > fseq)
return 1;
if (comps[i].co_fseq < fseq)
return -1;
return 0;
}
/** fseq based sort and lookup for components */
static daos_sort_ops_t fseq_sort_ops = {
.so_swap = fseq_sort_op_swap,
.so_cmp = fseq_sort_op_cmp,
.so_cmp_key = fseq_sort_op_cmp_key,
};
struct find_tgts_param {
uint32_t ftp_max_fseq;
uint32_t ftp_min_fseq;
uint8_t ftp_status;
unsigned long ftp_chk_max_fseq:1,
ftp_chk_min_fseq:1,
ftp_chk_status:1;
};
static bool
matched_criteria(struct find_tgts_param *param,
struct pool_target *tgt)
{
if (param->ftp_chk_status &&
!(param->ftp_status & tgt->ta_comp.co_status))
return false;
if (param->ftp_chk_max_fseq &&
param->ftp_max_fseq < tgt->ta_comp.co_fseq)
return false;
if (param->ftp_chk_min_fseq &&
param->ftp_min_fseq > tgt->ta_comp.co_fseq)
return false;
return true;
}
/**
* Find array of targets which match the query criteria. Caller is
* responsible for freeing the target array.
*
* \param map [IN] The pool map to search
* \param param [IN] Criteria to be checked
* \param sorter [IN] Sorter for the output targets array
* \param tgt_pp [OUT] The output target array, if tgt_pp == NULL, it only
* needs to get the tgt count, otherwise it will
* allocate the tgts array.
* \param tgt_cnt [OUT] The size of target array
*
* \return 0 on success, negative values on errors.
*/
static int
pool_map_find_tgts(struct pool_map *map, struct find_tgts_param *param,
daos_sort_ops_t *sorter, struct pool_target **tgt_pp,
unsigned int *tgt_cnt)
{
struct pool_target *targets;
int i, total_cnt, idx = 0;
if (tgt_pp != NULL)
*tgt_pp = NULL;
*tgt_cnt = 0;
if (pool_map_empty(map)) {
D_ERROR("Uninitialized pool map\n");
return 0;
}
/* pool map won't be changed between the two scans */
total_cnt = pool_map_target_nr(map);
targets = pool_map_targets(map);
rescan:
for (i = 0; i < total_cnt; i++) {
if (matched_criteria(param, &targets[i])) {
if (tgt_pp == NULL || *tgt_pp == NULL)
(*tgt_cnt)++;
else
(*(tgt_pp))[idx++] = targets[i];
}
}
if (*tgt_cnt == 0 || tgt_pp == NULL)
return 0;
if (*tgt_pp == NULL) {
D_ALLOC_ARRAY(*tgt_pp, *tgt_cnt);
if (*tgt_pp == NULL)
return -DER_NOMEM;
goto rescan;
} else if (sorter != NULL) {
daos_array_sort(*tgt_pp, *tgt_cnt, false, sorter);
}
return 0;
}
/**
* This function recursively scans the pool_map and records how many failures
* each domain contains. A domain is considered to have a failure if there are
* ANY failed targets within that domain. This is used to determine whether a
* pool meets a containers redundancy requirements when opening.
*
* \param dom [in] The pool domain currently being scanned.
* \param fail_cnts [in] The array used to track failures for each domain.
* \param domain_level [in] the current domain level used to index fail_cnts.
*
* \return returns the number of downstream failures found in "dom".
*/
static int
update_failed_cnt_helper(struct pool_domain *dom,
struct pool_fail_comp *fail_cnts, int domain_level)
{
struct pool_domain *next_dom;
int i;
int failed_children;
int num_failed = 0;
if (dom == NULL)
return 0;
if (dom->do_children == NULL) {
for (i = 0; i < dom->do_target_nr; ++i) {
if (pool_target_down(&dom->do_targets[i]))
num_failed++;
}
} else {
for (i = 0; i < dom->do_child_nr; ++i) {
next_dom = &dom->do_children[i];
failed_children = update_failed_cnt_helper(next_dom,
fail_cnts, domain_level + 1);
if (failed_children > 0)
num_failed++;
}
}
if (num_failed > 0)
fail_cnts[domain_level].fail_cnt++;
fail_cnts[domain_level].comp_type = dom->do_comp.co_type;
return num_failed;
}
/**
* Update the failed target count for the pool map.
* This should be called anytime the pool map is updated.
*/
int
pool_map_update_failed_cnt(struct pool_map *map)
{
int rc;
struct pool_domain *root;
struct pool_fail_comp *fail_cnts = map->po_comp_fail_cnts;
memset(fail_cnts, 0, sizeof(*fail_cnts) * map->po_domain_layers);
rc = pool_map_find_domain(map, PO_COMP_TP_ROOT, PO_COMP_ID_ALL, &root);
if (rc == 0)
return -DER_INVAL;
update_failed_cnt_helper(root, fail_cnts, 0);
return 0;
}
#define PMAP_VER_MAX ((uint32_t)-1)
#define PMAP_FAIL_INLINE_NR (8)
struct pmap_fail_ver {
uint32_t pf_start_ver;
uint32_t pf_end_ver;
};
struct pmap_fail_node {
struct pmap_fail_ver pf_ver_inline[PMAP_FAIL_INLINE_NR];
struct pmap_fail_ver *pf_vers;
uint32_t pf_co_rank;
uint32_t pf_ver_total; /* capacity of pf_vers array */
uint32_t pf_ver_nr; /* #valid items */
uint32_t pf_down:1, /* with DOWN tgt */
pf_new_fail:1; /* with new failure */
};
struct pmap_fail_stat {
struct pmap_fail_node pf_node_inline[PMAP_FAIL_INLINE_NR];
struct pmap_fail_node *pf_nodes;
uint32_t pf_node_total; /* capacity of pf_nodes array */
uint32_t pf_node_nr; /* #valid nodes */
/* #nodes in PO_COMP_ST_DOWN status */
uint32_t pf_down_nr;
/* #newly-failed-nodes with f_seq > last_ver */
uint32_t pf_newfail_nr;
/* version of checking last time (when user clear the UNCLEAN */
uint32_t pf_last_ver;
/* RF value */
uint32_t pf_rf;
};
static void
pmap_fail_node_init(struct pmap_fail_node *fnode)
{
fnode->pf_vers = fnode->pf_ver_inline;
fnode->pf_ver_total = PMAP_FAIL_INLINE_NR;
fnode->pf_ver_nr = 0;
memset(fnode->pf_vers, 0,
sizeof(struct pmap_fail_ver) * fnode->pf_ver_total);
}
static void
pmap_fail_node_fini(struct pmap_fail_node *fnode)
{
if (fnode->pf_vers != fnode->pf_ver_inline)
D_FREE(fnode->pf_vers);
}
static struct pmap_fail_node *
pmap_fail_node_get(struct pmap_fail_stat *fstat)
{
struct pmap_fail_node *fnodes;
struct pmap_fail_node *fnode;
uint32_t nr, i;
D_ASSERT(fstat->pf_node_nr <= fstat->pf_node_total);
if (fstat->pf_node_nr == fstat->pf_node_total) {
nr = fstat->pf_node_nr + PMAP_FAIL_INLINE_NR;
D_ALLOC_ARRAY(fnodes, nr);
if (fnodes == NULL)
return NULL;
memcpy(fnodes, fstat->pf_nodes,
sizeof(*fnode) * fstat->pf_node_nr);
for (i = 0; i < fstat->pf_node_nr; i++) {
fnode = &fstat->pf_nodes[i];
if (fnode->pf_vers != fnode->pf_ver_inline) {
D_ASSERT(fnode->pf_ver_nr >
PMAP_FAIL_INLINE_NR);
continue;
}
fnode = &fnodes[i];
D_ASSERT(fnode->pf_ver_nr <= PMAP_FAIL_INLINE_NR);
fnode->pf_vers = fnode->pf_ver_inline;
}
if (fstat->pf_nodes != fstat->pf_node_inline)
D_FREE(fstat->pf_nodes);
fstat->pf_nodes = fnodes;
fstat->pf_node_total = nr;
for (i = fstat->pf_node_nr; i < nr; i++)
pmap_fail_node_init(&fstat->pf_nodes[i]);
}
D_ASSERT(fstat->pf_node_nr < fstat->pf_node_total);
fnode = &fstat->pf_nodes[fstat->pf_node_nr++];
return fnode;
}
static void
pmap_fail_stat_init(struct pmap_fail_stat *stat, uint32_t last_ver, uint32_t rf)
{
int i;
stat->pf_nodes = stat->pf_node_inline;
stat->pf_node_total = PMAP_FAIL_INLINE_NR;
stat->pf_node_nr = 0;
stat->pf_down_nr = 0;
stat->pf_newfail_nr = 0;
stat->pf_last_ver = last_ver;
stat->pf_rf = rf;
for (i = 0; i < stat->pf_node_total; i++)
pmap_fail_node_init(&stat->pf_nodes[i]);
}
static void
pmap_fail_stat_fini(struct pmap_fail_stat *stat)
{
int i;
for (i = 0; i < stat->pf_node_nr; i++)
pmap_fail_node_fini(&stat->pf_nodes[i]);
if (stat->pf_nodes != stat->pf_node_inline)
D_FREE(stat->pf_nodes);
}
static bool
pmap_comp_failed(struct pool_component *comp)
{
return (comp->co_status == PO_COMP_ST_DOWN) ||
(comp->co_status == PO_COMP_ST_DOWNOUT &&
comp->co_flags == PO_COMPF_DOWN2OUT);
}
static bool
pmap_comp_failed_earlier(struct pool_component *comp, uint32_t ver)
{
return ((comp->co_status == PO_COMP_ST_DOWNOUT &&
comp->co_out_ver <= ver) ||
(comp->co_status == PO_COMP_ST_DOWN &&
comp->co_fseq <= ver));
}
static int
pmap_fver_cmp(void *array, int a, int b)
{
struct pmap_fail_ver *vers = array;
if (vers[a].pf_start_ver > vers[b].pf_start_ver)
return 1;
if (vers[a].pf_start_ver < vers[b].pf_start_ver)
return -1;
if (vers[a].pf_end_ver > vers[b].pf_end_ver)
return 1;
if (vers[a].pf_end_ver < vers[b].pf_end_ver)
return -1;
return 0;
}
static void
pmap_fver_swap(void *array, int a, int b)
{
struct pmap_fail_ver *vers = array;
struct pmap_fail_ver tmp;
tmp = vers[a];
vers[a] = vers[b];
vers[b] = tmp;
}
static daos_sort_ops_t pmap_fver_sort_ops = {
.so_cmp = pmap_fver_cmp,
.so_swap = pmap_fver_swap,
};
static bool
fver_overlap(struct pmap_fail_ver *a, struct pmap_fail_ver *b)
{
return (a->pf_start_ver <= b->pf_end_ver &&
b->pf_start_ver <= a->pf_end_ver);
}
static void
pmap_fail_ver_merge(struct pmap_fail_node *fnode)
{
struct pmap_fail_ver *ver1, *ver2;
int i, j;
if (fnode->pf_ver_nr < 2)
return;
for (i = 0; i < fnode->pf_ver_nr - 1;) {
ver1 = &fnode->pf_vers[i];
ver2 = &fnode->pf_vers[i + 1];
D_ASSERTF(ver1->pf_start_ver <= ver2->pf_start_ver,
"bad order of pf_start_ver %d, %d\n",
ver1->pf_start_ver, ver2->pf_start_ver);
/* exclude earlier, rebuild (exclude out) earlier */
D_ASSERTF(ver1->pf_end_ver <= ver2->pf_end_ver,
"bad order of pf_end_ver %d, %d\n",
ver1->pf_end_ver, ver2->pf_end_ver);
if (!fver_overlap(ver1, ver2)) {
i++;
continue;
}
ver1->pf_start_ver = min(ver1->pf_start_ver,
ver2->pf_start_ver);
ver1->pf_end_ver = max(ver1->pf_end_ver, ver2->pf_end_ver);
fnode->pf_ver_nr--;
if (i == fnode->pf_ver_nr - 2)
break;
for (j = i + 1; j < fnode->pf_ver_nr; j++)
fnode->pf_vers[j] = fnode->pf_vers[j + 1];
}
}
static int
pmap_fail_node_add_tgt(struct pmap_fail_stat *fstat,
struct pmap_fail_node *fnode,
struct pool_component *comp)
{
struct pmap_fail_ver *tmp, *fvers;
struct pmap_fail_ver ver;
uint32_t nr;
int i;
ver.pf_start_ver = comp->co_fseq;
if (comp->co_status == PO_COMP_ST_DOWN) {
fnode->pf_down = 1;
ver.pf_end_ver = PMAP_VER_MAX;
} else {
ver.pf_end_ver = comp->co_out_ver;
}
if (comp->co_fseq > fstat->pf_last_ver)
fnode->pf_new_fail = 1;
for (i = 0; i < fnode->pf_ver_nr; i++) {
tmp = &fnode->pf_vers[i];
if (fver_overlap(tmp, &ver)) {
tmp->pf_start_ver = min(tmp->pf_start_ver,
ver.pf_start_ver);
tmp->pf_end_ver = max(tmp->pf_end_ver,
ver.pf_end_ver);
return 0;
}
}
D_ASSERT(fnode->pf_ver_nr <= fnode->pf_ver_total);
if (fnode->pf_ver_nr == fnode->pf_ver_total) {
nr = fnode->pf_ver_nr + PMAP_FAIL_INLINE_NR;
D_ALLOC_ARRAY(fvers, nr);
if (fvers == NULL)
return -DER_NOMEM;
memcpy(fvers, fnode->pf_vers,
sizeof(*fvers) * fnode->pf_ver_nr);
if (fnode->pf_vers != fnode->pf_ver_inline)
D_FREE(fnode->pf_vers);
fnode->pf_vers = fvers;
fnode->pf_ver_total = nr;
}
D_ASSERT(fnode->pf_ver_nr < fnode->pf_ver_total);
fnode->pf_vers[fnode->pf_ver_nr] = ver;
fnode->pf_ver_nr++;
return 0;
}
static int
pmap_node_check(struct pool_domain *node_dom, struct pmap_fail_stat *fstat)
{
struct pmap_fail_node *fnode = NULL;
struct pool_target *tgt;
struct pool_component *comp;
int i;
int rc = 0;
for (i = 0; i < node_dom->do_target_nr; ++i) {
tgt = &node_dom->do_targets[i];
comp = &tgt->ta_comp;
if (!pmap_comp_failed(comp) ||
pmap_comp_failed_earlier(comp, fstat->pf_last_ver))
continue;
if (fnode == NULL) {
fnode = pmap_fail_node_get(fstat);
if (fnode == NULL)
return -DER_NOMEM;
}
rc = pmap_fail_node_add_tgt(fstat, fnode, comp);
if (rc)
return rc;
}
if (fnode == NULL || fnode->pf_ver_nr == 0)
return 0;
fnode->pf_co_rank = node_dom->do_comp.co_rank;
daos_array_sort(fnode->pf_vers, fnode->pf_ver_nr, false,
&pmap_fver_sort_ops);
pmap_fail_ver_merge(fnode);
if (fnode->pf_down)
fstat->pf_down_nr++;
if (fnode->pf_new_fail)
fstat->pf_newfail_nr++;
if ((fstat->pf_down_nr > fstat->pf_rf) && (fstat->pf_newfail_nr > 0)) {
rc = -DER_RF;
D_DEBUG(DB_TRACE, "RF broken, found %d DOWN node, "
"newly fail %d, rf %d, "DF_RC"\n", fstat->pf_down_nr,
fstat->pf_newfail_nr, fstat->pf_rf, DP_RC(rc));
}
return rc;
}
static int
pmap_fail_ver_overlap(struct pmap_fail_stat *fstat, struct pmap_fail_ver *fver)
{
struct pmap_fail_node *fnode;
struct pmap_fail_ver *tmp;
int i, j;
int nr;
bool ovl;
for (i = 0, nr = 0; i < fstat->pf_node_nr; i++) {
ovl = false;
fnode = &fstat->pf_nodes[i];
for (j = 0; j < fnode->pf_ver_nr; j++) {
tmp = &fnode->pf_vers[j];
if (fver_overlap(tmp, fver)) {
ovl = true;
break;
}
}
if (ovl)
nr++;
}
return nr;
}
static int
pmap_fail_stat_check(struct pmap_fail_stat *fstat)
{
struct pmap_fail_node *fnode;
struct pmap_fail_ver *fver;
uint32_t rf = fstat->pf_rf;
int max_fail_nr = 0;
int fail_nr;
uint32_t i, j;
int rc = 0;
/* First check some easier cases, it should cover most common cases */
if ((fstat->pf_node_nr <= rf) || (fstat->pf_newfail_nr == 0))
return 0;
if (fstat->pf_node_nr == 1) {
if (rf >= 1)
return 0;
rc = -DER_RF;
} else if (fstat->pf_down_nr > rf) {
rc = -DER_RF;
}
if (rc)
goto fail;
/* Bad corner case, need to check #max-concurrent-failures by checking
* overlapped fail version ranges between different nodes.
*/
for (i = 0; i < fstat->pf_node_nr; i++) {
fnode = &fstat->pf_nodes[i];
for (j = 0; j < fnode->pf_ver_nr; j++) {
fver = &fnode->pf_vers[j];
fail_nr = pmap_fail_ver_overlap(fstat, fver);
D_ASSERT(fail_nr >= 1);
if (fail_nr > max_fail_nr)
max_fail_nr = fail_nr;
if (max_fail_nr > rf) {
rc = -DER_RF;
break;
}
}
}
fail:
if (rc == -DER_RF) {
D_DEBUG(DB_TRACE, "RF broken, found %d fail, DOWN %d, newly "
"fail %d, max_overlapped %d, rf %d, "DF_RC"\n",
fstat->pf_node_nr, fstat->pf_down_nr,
fstat->pf_newfail_nr, max_fail_nr,
fstat->pf_rf, DP_RC(rc));
} else if (rc) {
D_ERROR("pmap_fail_stat_check, "DF_RC"\n", DP_RC(rc));
}
return rc;
}
/**
* Check if #concurrent_failures exceeds RF since pool map version \a last_ver.
*/
int
pool_map_rf_verify(struct pool_map *map, uint32_t last_ver, uint32_t rf)
{
struct pool_domain *node_doms;
struct pool_domain *node_dom;
struct pmap_fail_stat fstat;
int node_nr, i;
int rc = 0;
pmap_fail_stat_init(&fstat, last_ver, rf);
node_nr = pool_map_find_domain(map, PO_COMP_TP_RANK, PO_COMP_ID_ALL,
&node_doms);
D_ASSERT(node_nr >= 0);
if (node_nr == 0)
return -DER_INVAL;
for (i = 0; i < node_nr; i++) {
node_dom = &node_doms[i];
D_ASSERT(node_dom->do_children == NULL);
rc = pmap_node_check(node_dom, &fstat);
if (rc)
goto out;
}
rc = pmap_fail_stat_check(&fstat);
out:
pmap_fail_stat_fini(&fstat);
return rc;
}
/**
* Find all targets with @status in specific rank. Note: &tgt_pp will be
* allocated and the caller is responsible to free it.
*/
int
pool_map_find_by_rank_status(struct pool_map *map,
struct pool_target ***tgt_ppp,
unsigned int *tgt_cnt, unsigned int status,
d_rank_t rank)
{
struct pool_domain *dom;
int i;
*tgt_ppp = NULL;
*tgt_cnt = 0;
dom = pool_map_find_node_by_rank(map, rank);
if (dom == NULL)
return 0;
for (i = 0; i < dom->do_target_nr; i++) {
if (dom->do_targets[i].ta_comp.co_status & status) {
if (*tgt_ppp == NULL) {
D_ALLOC_ARRAY(*tgt_ppp, dom->do_target_nr);
if (*tgt_ppp == NULL)
return -DER_NOMEM;
}
(*tgt_ppp)[(*tgt_cnt)++] = &dom->do_targets[i];
}
}
return 0;
}
/**
* Find all targets with DOWN|DOWNOUT state in specific rank.
*/
int
pool_map_find_failed_tgts_by_rank(struct pool_map *map,
struct pool_target ***tgt_ppp,
unsigned int *tgt_cnt, d_rank_t rank)
{
unsigned int status;
status = PO_COMP_ST_DOWN | PO_COMP_ST_DOWNOUT | PO_COMP_ST_DRAIN;
return pool_map_find_by_rank_status(map, tgt_ppp, tgt_cnt, status,
rank);
}
int
pool_map_find_tgts_by_state(struct pool_map *map,
pool_comp_state_t match_states,
struct pool_target **tgt_pp, unsigned int *tgt_cnt)
{
struct find_tgts_param param;
param.ftp_max_fseq = 0;
param.ftp_min_fseq = 0;
param.ftp_status = match_states;
param.ftp_chk_max_fseq = 0;
param.ftp_chk_min_fseq = 0;
param.ftp_chk_status = 1;
return pool_map_find_tgts(map, ¶m, &fseq_sort_ops, tgt_pp, tgt_cnt);
}
/**
* Find all targets in UP state. (but not included in the pool for active I/O
* i.e. UP_IN). Raft leader can use it drive target reintegration/addition.
*/
int
pool_map_find_up_tgts(struct pool_map *map, struct pool_target **tgt_pp,
unsigned int *tgt_cnt)
{
return pool_map_find_tgts_by_state(map,
PO_COMP_ST_UP,
tgt_pp, tgt_cnt);
}
/**
* Find all targets in DOWN state. Raft leader can use it drive target
* rebuild one by one.
*/
int
pool_map_find_down_tgts(struct pool_map *map, struct pool_target **tgt_pp,
unsigned int *tgt_cnt)
{
return pool_map_find_tgts_by_state(map,
PO_COMP_ST_DOWN,
tgt_pp, tgt_cnt);
}
/**
* Find all targets in DOWN|DOWNOUT state.
*
* Note that this does not return DRAIN targets, because those are still healthy
* while they are draining
*/
int
pool_map_find_failed_tgts(struct pool_map *map, struct pool_target **tgt_pp,
unsigned int *tgt_cnt)
{
return pool_map_find_tgts_by_state(map,
PO_COMP_ST_DOWN | PO_COMP_ST_DOWNOUT,
tgt_pp, tgt_cnt);
}
/**
* Find all targets in UPIN state (included in the pool for active I/O).
*/
int
pool_map_find_upin_tgts(struct pool_map *map, struct pool_target **tgt_pp,
unsigned int *tgt_cnt)
{
return pool_map_find_tgts_by_state(map,
PO_COMP_ST_UPIN,
tgt_pp, tgt_cnt);
}
static void
pool_domain_print(struct pool_domain *domain, int dep)
{
int i;
D_PRINT("%*s%s[%d] v%d %s\n", dep * 8, "", pool_domain_name(domain),
domain->do_comp.co_id, domain->do_comp.co_ver,
pool_comp_state2str(domain->do_comp.co_status));
D_ASSERT(domain->do_targets != NULL);
if (domain->do_children != NULL) {
for (i = 0; i < domain->do_child_nr; i++)
pool_domain_print(&domain->do_children[i], dep + 1);
return;
}
for (i = 0; i < domain->do_target_nr; i++) {
struct pool_component *comp = &domain->do_targets[i].ta_comp;
D_ASSERTF(comp->co_type == PO_COMP_TP_TARGET,
"%s\n", pool_comp_type2str(comp->co_type));
D_PRINT("%*s%s[%d] v%d %s (fseq=%d)\n", (dep + 1) * 8, "",
pool_comp_type2str(comp->co_type),
comp->co_id, comp->co_ver,
pool_comp_state2str(comp->co_status),
comp->co_fseq);
}
}
/**
* Print all components of the pool map, this is a debug function.
*/
void
pool_map_print(struct pool_map *map)
{
D_PRINT("Cluster map version %d\n", map->po_version);
if (map->po_tree != NULL)
pool_domain_print(map->po_tree, 0);
}
/**
* Return the version of the pool map.
*/
unsigned int
pool_map_get_version(struct pool_map *map)
{
D_DEBUG(DB_TRACE, "Fetch pool map version %u\n", map->po_version);
D_ASSERT(map != NULL);
return map->po_version;
}
/**
* Update the version of the pool map.
*/
int
pool_map_set_version(struct pool_map *map, uint32_t version)
{
if (map->po_version > version) {
D_ERROR("Cannot decrease pool map version %u/%u\n",
map->po_version, version);
return -DER_NO_PERM;
}
if (map->po_version == version)
return 0;
D_DEBUG(DB_TRACE, "Update pool map version %u->%u\n",
map->po_version, version);
map->po_version = version;
return 0;
}
int
pool_map_get_failed_cnt(struct pool_map *map, uint32_t domain)
{
int i;
int fail_cnt = -1;
for (i = 0; i < map->po_domain_layers; ++i) {
if (map->po_comp_fail_cnts[i].comp_type == domain) {
fail_cnt = map->po_comp_fail_cnts[i].fail_cnt;
break;
}
}
if (fail_cnt == -1)
return -DER_NONEXIST;
return fail_cnt;
}
/**
* check if the pool map is empty
*/
static bool
pool_map_empty(struct pool_map *map)
{
return map->po_tree == NULL;
}
static bool
pool_target_id_found(struct pool_target_id_list *id_list,
struct pool_target_id *tgt)
{
int i;
for (i = 0; i < id_list->pti_number; i++)
if (id_list->pti_ids[i].pti_id == tgt->pti_id)
return true;
return false;
}
int
pool_target_id_list_append(struct pool_target_id_list *id_list,
struct pool_target_id *id)
{
struct pool_target_id *new_ids;
int rc = 0;
if (pool_target_id_found(id_list, id))
return 0;
D_REALLOC_ARRAY(new_ids, id_list->pti_ids, id_list->pti_number,
id_list->pti_number + 1);
if (new_ids == NULL)
return -DER_NOMEM;
new_ids[id_list->pti_number] = *id;
id_list->pti_ids = new_ids;
id_list->pti_number++;
return rc;
}
int
pool_target_id_list_merge(struct pool_target_id_list *dst_list,
struct pool_target_id_list *src_list)
{
int i;
int rc = 0;
for (i = 0; i < src_list->pti_number; i++) {
rc = pool_target_id_list_append(dst_list,
&src_list->pti_ids[i]);
if (rc)
break;
}
return rc;
}
int
pool_target_id_list_alloc(unsigned int num,
struct pool_target_id_list *id_list)
{
D_ALLOC_ARRAY(id_list->pti_ids, num);
if (id_list->pti_ids == NULL)
return -DER_NOMEM;
id_list->pti_number = num;
return 0;
}
void
pool_target_id_list_free(struct pool_target_id_list *id_list)
{
if (id_list == NULL)
return;
if (id_list->pti_ids)
D_FREE(id_list->pti_ids);
}
|
637380.c | /*
* inet fragments management
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* Authors: Pavel Emelyanov <[email protected]>
* Started as consolidation of ipv4/ip_fragment.c,
* ipv6/reassembly. and ipv6 nf conntrack reassembly
*/
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/random.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/slab.h>
#include <net/inet_frag.h>
static void inet_frag_secret_rebuild(unsigned long dummy)
{
struct inet_frags *f = (struct inet_frags *)dummy;
unsigned long now = jiffies;
int i;
write_lock(&f->lock);
get_random_bytes(&f->rnd, sizeof(u32));
for (i = 0; i < INETFRAGS_HASHSZ; i++) {
struct inet_frag_queue *q;
struct hlist_node *p, *n;
hlist_for_each_entry_safe(q, p, n, &f->hash[i], list) {
unsigned int hval = f->hashfn(q);
if (hval != i) {
hlist_del(&q->list);
/* Relink to new hash chain. */
hlist_add_head(&q->list, &f->hash[hval]);
}
}
}
write_unlock(&f->lock);
mod_timer(&f->secret_timer, now + f->secret_interval);
}
void inet_frags_init(struct inet_frags *f)
{
int i;
for (i = 0; i < INETFRAGS_HASHSZ; i++)
INIT_HLIST_HEAD(&f->hash[i]);
rwlock_init(&f->lock);
f->rnd = (u32) ((num_physpages ^ (num_physpages>>7)) ^
(jiffies ^ (jiffies >> 6)));
setup_timer(&f->secret_timer, inet_frag_secret_rebuild,
(unsigned long)f);
f->secret_timer.expires = jiffies + f->secret_interval;
add_timer(&f->secret_timer);
}
EXPORT_SYMBOL(inet_frags_init);
void inet_frags_init_net(struct netns_frags *nf)
{
nf->nqueues = 0;
atomic_set(&nf->mem, 0);
INIT_LIST_HEAD(&nf->lru_list);
}
EXPORT_SYMBOL(inet_frags_init_net);
void inet_frags_fini(struct inet_frags *f)
{
del_timer(&f->secret_timer);
}
EXPORT_SYMBOL(inet_frags_fini);
void inet_frags_exit_net(struct netns_frags *nf, struct inet_frags *f)
{
nf->low_thresh = 0;
local_bh_disable();
inet_frag_evictor(nf, f);
local_bh_enable();
}
EXPORT_SYMBOL(inet_frags_exit_net);
static inline void fq_unlink(struct inet_frag_queue *fq, struct inet_frags *f)
{
write_lock(&f->lock);
hlist_del(&fq->list);
list_del(&fq->lru_list);
fq->net->nqueues--;
write_unlock(&f->lock);
}
void inet_frag_kill(struct inet_frag_queue *fq, struct inet_frags *f)
{
if (del_timer(&fq->timer))
atomic_dec(&fq->refcnt);
if (!(fq->last_in & INET_FRAG_COMPLETE)) {
fq_unlink(fq, f);
atomic_dec(&fq->refcnt);
fq->last_in |= INET_FRAG_COMPLETE;
}
}
EXPORT_SYMBOL(inet_frag_kill);
static inline void frag_kfree_skb(struct netns_frags *nf, struct inet_frags *f,
struct sk_buff *skb, int *work)
{
if (work)
*work -= skb->truesize;
atomic_sub(skb->truesize, &nf->mem);
if (f->skb_free)
f->skb_free(skb);
kfree_skb(skb);
}
void inet_frag_destroy(struct inet_frag_queue *q, struct inet_frags *f,
int *work)
{
struct sk_buff *fp;
struct netns_frags *nf;
WARN_ON(!(q->last_in & INET_FRAG_COMPLETE));
WARN_ON(del_timer(&q->timer) != 0);
/* Release all fragment data. */
fp = q->fragments;
nf = q->net;
while (fp) {
struct sk_buff *xp = fp->next;
frag_kfree_skb(nf, f, fp, work);
fp = xp;
}
if (work)
*work -= f->qsize;
atomic_sub(f->qsize, &nf->mem);
if (f->destructor)
f->destructor(q);
kfree(q);
}
EXPORT_SYMBOL(inet_frag_destroy);
int inet_frag_evictor(struct netns_frags *nf, struct inet_frags *f)
{
struct inet_frag_queue *q;
int work, evicted = 0;
work = atomic_read(&nf->mem) - nf->low_thresh;
while (work > 0) {
read_lock(&f->lock);
if (list_empty(&nf->lru_list)) {
read_unlock(&f->lock);
break;
}
q = list_first_entry(&nf->lru_list,
struct inet_frag_queue, lru_list);
atomic_inc(&q->refcnt);
read_unlock(&f->lock);
spin_lock(&q->lock);
if (!(q->last_in & INET_FRAG_COMPLETE))
inet_frag_kill(q, f);
spin_unlock(&q->lock);
if (atomic_dec_and_test(&q->refcnt))
inet_frag_destroy(q, f, &work);
evicted++;
}
return evicted;
}
EXPORT_SYMBOL(inet_frag_evictor);
static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
struct inet_frag_queue *qp_in, struct inet_frags *f,
void *arg)
{
struct inet_frag_queue *qp;
#ifdef CONFIG_SMP
struct hlist_node *n;
#endif
unsigned int hash;
write_lock(&f->lock);
/*
* While we stayed w/o the lock other CPU could update
* the rnd seed, so we need to re-calculate the hash
* chain. Fortunatelly the qp_in can be used to get one.
*/
hash = f->hashfn(qp_in);
#ifdef CONFIG_SMP
/* With SMP race we have to recheck hash table, because
* such entry could be created on other cpu, while we
* promoted read lock to write lock.
*/
hlist_for_each_entry(qp, n, &f->hash[hash], list) {
if (qp->net == nf && f->match(qp, arg)) {
atomic_inc(&qp->refcnt);
write_unlock(&f->lock);
qp_in->last_in |= INET_FRAG_COMPLETE;
inet_frag_put(qp_in, f);
return qp;
}
}
#endif
qp = qp_in;
if (!mod_timer(&qp->timer, jiffies + nf->timeout))
atomic_inc(&qp->refcnt);
atomic_inc(&qp->refcnt);
hlist_add_head(&qp->list, &f->hash[hash]);
list_add_tail(&qp->lru_list, &nf->lru_list);
nf->nqueues++;
write_unlock(&f->lock);
return qp;
}
static struct inet_frag_queue *inet_frag_alloc(struct netns_frags *nf,
struct inet_frags *f, void *arg)
{
struct inet_frag_queue *q;
q = kzalloc(f->qsize, GFP_ATOMIC);
if (q == NULL)
return NULL;
q->net = nf;
f->constructor(q, arg);
atomic_add(f->qsize, &nf->mem);
setup_timer(&q->timer, f->frag_expire, (unsigned long)q);
spin_lock_init(&q->lock);
atomic_set(&q->refcnt, 1);
return q;
}
static struct inet_frag_queue *inet_frag_create(struct netns_frags *nf,
struct inet_frags *f, void *arg)
{
struct inet_frag_queue *q;
q = inet_frag_alloc(nf, f, arg);
if (q == NULL)
return NULL;
return inet_frag_intern(nf, q, f, arg);
}
struct inet_frag_queue *inet_frag_find(struct netns_frags *nf,
struct inet_frags *f, void *key, unsigned int hash)
__releases(&f->lock)
{
struct inet_frag_queue *q;
struct hlist_node *n;
hlist_for_each_entry(q, n, &f->hash[hash], list) {
if (q->net == nf && f->match(q, key)) {
atomic_inc(&q->refcnt);
read_unlock(&f->lock);
return q;
}
}
read_unlock(&f->lock);
return inet_frag_create(nf, f, key);
}
EXPORT_SYMBOL(inet_frag_find);
|
399017.c | $NetBSD: patch-decode.c,v 1.1 2015/04/12 15:54:02 tnn Exp $
Fix CVE-2015-2782. Via Debian security-afl.patch.
--- decode.c.orig 2003-04-12 16:15:58.000000000 +0000
+++ decode.c
@@ -255,7 +255,7 @@ void read_pt_len(int nn, int nbit, int i
if(i==i_special)
{
c=getbits(2);
- while(--c>=0)
+ while(--c>=0&&i<nn)
pt_len[i++]=0;
}
}
@@ -314,10 +314,10 @@ void read_c_len()
c=getbits(CBIT);
c+=20;
}
- while(--c>=0)
+ while(--c>=0&&i<NC)
c_len[i++]=0;
}
- else
+ else if (i<NC)
c_len[i++]=(unsigned char)(c-2);
}
while(i<NC)
|
336855.c | /*
* conf.c: implementation of the internal storage format used for
* the configuration of a PuTTY session.
*/
#include <stdio.h>
#include <stddef.h>
#include <assert.h>
#include "tree234.h"
#include "putty.h"
/*
* Enumeration of types used in keys and values.
*/
typedef enum { TYPE_NONE, TYPE_INT, TYPE_STR, TYPE_FILENAME, TYPE_FONT } Type;
/*
* Arrays which allow us to look up the subkey and value types for a
* given primary key id.
*/
#define CONF_SUBKEYTYPE_DEF(valtype, keytype, keyword) TYPE_ ## keytype,
static int subkeytypes[] = { CONFIG_OPTIONS(CONF_SUBKEYTYPE_DEF) };
#define CONF_VALUETYPE_DEF(valtype, keytype, keyword) TYPE_ ## valtype,
static int valuetypes[] = { CONFIG_OPTIONS(CONF_VALUETYPE_DEF) };
/*
* Configuration keys are primarily integers (big enum of all the
* different configurable options); some keys have string-designated
* subkeys, such as the list of environment variables (subkeys
* defined by the variable names); some have integer-designated
* subkeys (wordness, colours, preference lists).
*/
struct key {
int primary;
union {
int i;
char *s;
} secondary;
};
/* Variant form of struct key which doesn't contain dynamic data, used
* for lookups. */
struct constkey {
int primary;
union {
int i;
const char *s;
} secondary;
};
struct value {
union {
int intval;
char *stringval;
Filename *fileval;
FontSpec *fontval;
} u;
};
struct conf_entry {
struct key key;
struct value value;
};
struct conf_tag {
tree234 *tree;
};
/*
* Because 'struct key' is the first element in 'struct conf_entry',
* it's safe (guaranteed by the C standard) to cast arbitrarily back
* and forth between the two types. Therefore, we only need one
* comparison function, which can double as a main sort function for
* the tree (comparing two conf_entry structures with each other)
* and a search function (looking up an externally supplied key).
*/
static int conf_cmp(void *av, void *bv)
{
struct key *a = (struct key *)av;
struct key *b = (struct key *)bv;
if (a->primary < b->primary)
return -1;
else if (a->primary > b->primary)
return +1;
switch (subkeytypes[a->primary]) {
case TYPE_INT:
if (a->secondary.i < b->secondary.i)
return -1;
else if (a->secondary.i > b->secondary.i)
return +1;
return 0;
case TYPE_STR:
return strcmp(a->secondary.s, b->secondary.s);
default:
return 0;
}
}
static int conf_cmp_constkey(void *av, void *bv)
{
struct key *a = (struct key *)av;
struct constkey *b = (struct constkey *)bv;
if (a->primary < b->primary)
return -1;
else if (a->primary > b->primary)
return +1;
switch (subkeytypes[a->primary]) {
case TYPE_INT:
if (a->secondary.i < b->secondary.i)
return -1;
else if (a->secondary.i > b->secondary.i)
return +1;
return 0;
case TYPE_STR:
return strcmp(a->secondary.s, b->secondary.s);
default:
return 0;
}
}
/*
* Free any dynamic data items pointed to by a 'struct key'. We
* don't free the structure itself, since it's probably part of a
* larger allocated block.
*/
static void free_key(struct key *key)
{
if (subkeytypes[key->primary] == TYPE_STR)
sfree(key->secondary.s);
}
/*
* Copy a 'struct key' into another one, copying its dynamic data
* if necessary.
*/
static void copy_key(struct key *to, struct key *from)
{
to->primary = from->primary;
switch (subkeytypes[to->primary]) {
case TYPE_INT:
to->secondary.i = from->secondary.i;
break;
case TYPE_STR:
to->secondary.s = dupstr(from->secondary.s);
break;
}
}
/*
* Free any dynamic data items pointed to by a 'struct value'. We
* don't free the value itself, since it's probably part of a larger
* allocated block.
*/
static void free_value(struct value *val, int type)
{
if (type == TYPE_STR)
sfree(val->u.stringval);
else if (type == TYPE_FILENAME)
filename_free(val->u.fileval);
else if (type == TYPE_FONT)
fontspec_free(val->u.fontval);
}
/*
* Copy a 'struct value' into another one, copying its dynamic data
* if necessary.
*/
static void copy_value(struct value *to, struct value *from, int type)
{
switch (type) {
case TYPE_INT:
to->u.intval = from->u.intval;
break;
case TYPE_STR:
to->u.stringval = dupstr(from->u.stringval);
break;
case TYPE_FILENAME:
to->u.fileval = filename_copy(from->u.fileval);
break;
case TYPE_FONT:
to->u.fontval = fontspec_copy(from->u.fontval);
break;
}
}
/*
* Free an entire 'struct conf_entry' and its dynamic data.
*/
static void free_entry(struct conf_entry *entry)
{
free_key(&entry->key);
free_value(&entry->value, valuetypes[entry->key.primary]);
sfree(entry);
}
Conf *conf_new(void)
{
Conf *conf = snew(struct conf_tag);
conf->tree = newtree234(conf_cmp);
return conf;
}
void conf_clear(Conf *conf)
{
struct conf_entry *entry;
while ((entry = (struct conf_entry *)delpos234(conf->tree, 0)) != NULL)
free_entry(entry);
}
void conf_free(Conf *&conf)
{
if (conf == NULL){ return; }
conf_clear(conf);
freetree234(conf->tree);
sfree(conf);
conf = NULL;
}
static void conf_insert(Conf *conf, struct conf_entry *entry)
{
struct conf_entry *oldentry = (struct conf_entry *)add234(conf->tree, entry);
if (oldentry && oldentry != entry) {
del234(conf->tree, oldentry);
free_entry(oldentry);
oldentry = (struct conf_entry *)add234(conf->tree, entry);
assert(oldentry == entry);
}
}
void conf_copy_into(Conf *newconf, Conf *oldconf)
{
struct conf_entry *entry, *entry2;
int i;
conf_clear(newconf);
for (i = 0; (entry = (struct conf_entry *)index234(oldconf->tree, i)) != NULL; i++) {
entry2 = snew(struct conf_entry);
copy_key(&entry2->key, &entry->key);
copy_value(&entry2->value, &entry->value,
valuetypes[entry->key.primary]);
add234(newconf->tree, entry2);
}
}
Conf *conf_copy(Conf *oldconf)
{
Conf *newconf = conf_new();
conf_copy_into(newconf, oldconf);
return newconf;
}
int conf_get_int(Conf *conf, int primary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_INT);
key.primary = primary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
assert(entry);
return entry->value.u.intval;
}
bool conf_try_get_int_int(Conf *conf, int primary, int secondary, int& ret)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_INT);
key.primary = primary;
key.secondary.i = secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
if (entry == NULL){ return false; }
ret = entry->value.u.intval;
return true;
}
int conf_get_int_int(Conf *conf, int primary, int secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_INT);
key.primary = primary;
key.secondary.i = secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
assert(entry);
return entry->value.u.intval;
}
char *conf_get_str(Conf *conf, int primary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
assert(entry);
return entry->value.u.stringval;
}
char *conf_get_str_str_opt(Conf *conf, int primary, const char *secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_STR);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
key.secondary.s = (char *)secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
return entry ? entry->value.u.stringval : NULL;
}
char *conf_get_str_str(Conf *conf, int primary, const char *secondary)
{
char *ret = conf_get_str_str_opt(conf, primary, secondary);
assert(ret);
return ret;
}
char *conf_get_str_strs(Conf *conf, int primary,
char *subkeyin, char **subkeyout)
{
struct constkey key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_STR);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
if (subkeyin) {
key.secondary.s = subkeyin;
entry = (struct conf_entry *)findrel234(conf->tree, &key, NULL, REL234_GT);
} else {
key.secondary.s = "";
entry = (struct conf_entry *)findrel234(conf->tree, &key, conf_cmp_constkey, REL234_GE);
}
if (!entry || entry->key.primary != primary)
return NULL;
*subkeyout = entry->key.secondary.s;
return entry->value.u.stringval;
}
char *conf_get_str_nthstrkey(Conf *conf, int primary, int n)
{
struct constkey key;
struct conf_entry *entry;
int index;
assert(subkeytypes[primary] == TYPE_STR);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
key.secondary.s = "";
entry = (struct conf_entry *)findrelpos234(conf->tree, &key, conf_cmp_constkey,
REL234_GE, &index);
if (!entry || entry->key.primary != primary)
return NULL;
entry = (struct conf_entry *)index234(conf->tree, index + n);
if (!entry || entry->key.primary != primary)
return NULL;
return entry->key.secondary.s;
}
Filename *conf_get_filename(Conf *conf, int primary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_FILENAME);
key.primary = primary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
assert(entry);
return entry->value.u.fileval;
}
FontSpec *conf_get_fontspec(Conf *conf, int primary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_FONT);
key.primary = primary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
assert(entry);
return entry->value.u.fontval;
}
void conf_set_int(Conf *conf, int primary, int value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_INT);
entry->key.primary = primary;
entry->value.u.intval = value;
conf_insert(conf, entry);
}
void conf_set_int_int(Conf *conf, int primary, int secondary, int value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_INT);
entry->key.primary = primary;
entry->key.secondary.i = secondary;
entry->value.u.intval = value;
conf_insert(conf, entry);
}
void conf_set_str(Conf *conf, int primary, const char *value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_STR);
entry->key.primary = primary;
entry->value.u.stringval = dupstr(value);
conf_insert(conf, entry);
}
void conf_set_str_str(Conf *conf, int primary, const char *secondary,
const char *value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_STR);
assert(valuetypes[primary] == TYPE_STR);
entry->key.primary = primary;
entry->key.secondary.s = dupstr(secondary);
entry->value.u.stringval = dupstr(value);
conf_insert(conf, entry);
}
void conf_del_str_str(Conf *conf, int primary, const char *secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_STR);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
key.secondary.s = (char *)secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
if (entry) {
del234(conf->tree, entry);
free_entry(entry);
}
}
void conf_del_int_int(Conf *conf, int primary, int secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_INT);
key.primary = primary;
key.secondary.i = secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
if (entry) {
del234(conf->tree, entry);
free_entry(entry);
}
}
void conf_del_int_str(Conf *conf, int primary, int secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
key.secondary.i = secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
if (entry) {
del234(conf->tree, entry);
free_entry(entry);
}
}
void conf_set_filename(Conf *conf, int primary, const Filename *value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_FILENAME);
entry->key.primary = primary;
entry->value.u.fileval = filename_copy(value);
conf_insert(conf, entry);
}
void conf_set_fontspec(Conf *conf, int primary, const FontSpec *value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_FONT);
entry->key.primary = primary;
entry->value.u.fontval = fontspec_copy(value);
conf_insert(conf, entry);
}
int conf_serialised_size(Conf *conf)
{
int i;
struct conf_entry *entry;
int size = 0;
for (i = 0; (entry = (struct conf_entry *)index234(conf->tree, i)) != NULL; i++) {
size += 4; /* primary key */
switch (subkeytypes[entry->key.primary]) {
case TYPE_INT:
size += 4;
break;
case TYPE_STR:
size += 1 + strlen(entry->key.secondary.s);
break;
}
switch (valuetypes[entry->key.primary]) {
case TYPE_INT:
size += 4;
break;
case TYPE_STR:
size += 1 + strlen(entry->value.u.stringval);
break;
case TYPE_FILENAME:
size += filename_serialise(entry->value.u.fileval, NULL);
break;
case TYPE_FONT:
size += fontspec_serialise(entry->value.u.fontval, NULL);
break;
}
}
size += 4; /* terminator value */
return size;
}
void conf_serialise(Conf *conf, void *vdata)
{
unsigned char *data = (unsigned char *)vdata;
int i, len;
struct conf_entry *entry;
for (i = 0; (entry = (struct conf_entry *)index234(conf->tree, i)) != NULL; i++) {
PUT_32BIT_MSB_FIRST(data, entry->key.primary);
data += 4;
switch (subkeytypes[entry->key.primary]) {
case TYPE_INT:
PUT_32BIT_MSB_FIRST(data, entry->key.secondary.i);
data += 4;
break;
case TYPE_STR:
len = strlen(entry->key.secondary.s);
memcpy(data, entry->key.secondary.s, len);
data += len;
*data++ = 0;
break;
}
switch (valuetypes[entry->key.primary]) {
case TYPE_INT:
PUT_32BIT_MSB_FIRST(data, entry->value.u.intval);
data += 4;
break;
case TYPE_STR:
len = strlen(entry->value.u.stringval);
memcpy(data, entry->value.u.stringval, len);
data += len;
*data++ = 0;
break;
case TYPE_FILENAME:
data += filename_serialise(entry->value.u.fileval, data);
break;
case TYPE_FONT:
data += fontspec_serialise(entry->value.u.fontval, data);
break;
}
}
PUT_32BIT_MSB_FIRST(data, 0xFFFFFFFFU);
}
int conf_deserialise(Conf *conf, void *vdata, int maxsize)
{
unsigned char *data = (unsigned char *)vdata;
unsigned char *start = data;
struct conf_entry *entry;
unsigned primary;
int used;
unsigned char *zero;
while (maxsize >= 4) {
primary = GET_32BIT_MSB_FIRST(data);
data += 4, maxsize -= 4;
if (primary >= N_CONFIG_OPTIONS)
break;
entry = snew(struct conf_entry);
entry->key.primary = primary;
switch (subkeytypes[entry->key.primary]) {
case TYPE_INT:
if (maxsize < 4) {
sfree(entry);
goto done;
}
entry->key.secondary.i = toint(GET_32BIT_MSB_FIRST(data));
data += 4, maxsize -= 4;
break;
case TYPE_STR:
zero = (unsigned char*)memchr(data, 0, maxsize);
if (!zero) {
sfree(entry);
goto done;
}
entry->key.secondary.s = dupstr((char *)data);
maxsize -= (zero + 1 - data);
data = zero + 1;
break;
}
switch (valuetypes[entry->key.primary]) {
case TYPE_INT:
if (maxsize < 4) {
if (subkeytypes[entry->key.primary] == TYPE_STR)
sfree(entry->key.secondary.s);
sfree(entry);
goto done;
}
entry->value.u.intval = toint(GET_32BIT_MSB_FIRST(data));
data += 4, maxsize -= 4;
break;
case TYPE_STR:
zero = (unsigned char*)memchr(data, 0, maxsize);
if (!zero) {
if (subkeytypes[entry->key.primary] == TYPE_STR)
sfree(entry->key.secondary.s);
sfree(entry);
goto done;
}
entry->value.u.stringval = dupstr((char *)data);
maxsize -= (zero + 1 - data);
data = zero + 1;
break;
case TYPE_FILENAME:
entry->value.u.fileval =
filename_deserialise(data, maxsize, &used);
if (!entry->value.u.fileval) {
if (subkeytypes[entry->key.primary] == TYPE_STR)
sfree(entry->key.secondary.s);
sfree(entry);
goto done;
}
data += used;
maxsize -= used;
break;
case TYPE_FONT:
entry->value.u.fontval =
fontspec_deserialise(data, maxsize, &used);
if (!entry->value.u.fontval) {
if (subkeytypes[entry->key.primary] == TYPE_STR)
sfree(entry->key.secondary.s);
sfree(entry);
goto done;
}
data += used;
maxsize -= used;
break;
}
conf_insert(conf, entry);
}
done:
return (int)(data - start);
}
char* conf_get_int_str_opt(Conf *conf, int primary, int secondary)
{
struct key key;
struct conf_entry *entry;
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_STR);
key.primary = primary;
key.secondary.i = secondary;
entry = (struct conf_entry *)find234(conf->tree, &key, NULL);
return entry->value.u.stringval;
}
char* conf_get_int_str(Conf *conf, int primary, int secondary)
{
char *ret = conf_get_int_str_opt(conf, primary, secondary);
assert(ret);
return ret;
}
void conf_set_int_str(Conf *conf, int primary, int secondary, const char* value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_INT);
assert(valuetypes[primary] == TYPE_STR);
entry->key.primary = primary;
entry->key.secondary.i = secondary;
entry->value.u.stringval = dupstr(value);
conf_insert(conf, entry);
}
|
903364.c | #include "types.h"
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
#include "x86.h"
static void startothers(void);
static void mpmain(void) __attribute__((noreturn));
extern pde_t *kpgdir;
// kernel.ld: PROVIDE(end = .);
// watch on clion:
// - (void *)end
// - (void *)PGROUNDUP((uint)end)
extern char end[]; // first address after kernel loaded from ELF file
// Bootstrap processor starts running C code here.
// Allocate a real stack and switch to it, first
// doing some setup required for memory allocator to work.
int
main(void)
{
// initialize:
// (void *)PGROUNDUP((uint)end) <= (this range) < 8040_0000 (KERNBASE + 4Mi)
//
// PGSIZE 4096 0x1000 4Ki
//
// ooo: not include
// xxx: include
//
// P2V(4Mi) 0x8040_0000 ooo
// 0x803f_f000 | <- kmem.freelist right after kinit1()
// 0x803f_e000 |
// 0x803f_d000 |
// 0x803f_c000 |
// |
// ROUNDUP 0x8011_6000 xxx
// (void *)end 0x8011_5488
// KERNBASE 0x8000_0000
kinit1(end, P2V(4*1024*1024)); // phys page allocator
{
// evaluate: (struct run *)0x80117000
// kmem.freelist -> 803ff000 -> 803fe000 -> 803fd000 -> ... ->
// 0x80117000 -> 0x80116000 -> NULL
// kfree((char *)0x803fd000); // collapse
// kmem.freelist -> 803ff000 -> 803fe000 -> 803fd000 -> ...
void *tmp1 = kalloc(); // 803ff000
// kmem.freelist -> 803fe000 -> 803fd000 -> ...
void *tmp2 = kalloc(); // 803fe000
// kmem.freelist -> 803fd000 -> ...
kfree(tmp1);
// kmem.freelist -> 803ff000 -> 803fd000 -> ...
void *tmp3 = kalloc(); // 803ff000
// kmem.freelist -> 803fd000 -> ...
kfree(tmp2);
// kmem.freelist -> 803fe000 -> 803fd000 -> ...
kfree(tmp3);
// kmem.freelist -> 803ff000 -> 803fe000 -> 803fd000 -> ...
}
kvmalloc(); // kernel page table
mpinit(); // detect other processors
lapicinit(); // interrupt controller
seginit(); // segment descriptors
picinit(); // disable pic
ioapicinit(); // another interrupt controller
consoleinit(); // console hardware
log_info("console_init() done"); // printed out to only vga
uartinit(); // serial port
log_info("uart_init() done"); // printed out to both vga and console
pinit(); // process table
tvinit(); // trap vectors
binit(); // buffer cache
fileinit(); // file table
ideinit(); // disk
startothers(); // start other processors
kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
// TODO
userinit(); // first user process
mpmain(); // finish this processor's setup
}
// Other CPUs jump here from entryother.S.
static void
mpenter(void)
{
// (gdb) info r eip
// eip 0x80103b34 0x80103b34 <mpenter>
// switchkvm() (cr3設定の前) からvirtual address?? lgdtで設定済だったっけ？
switchkvm();
seginit();
lapicinit();
mpmain();
}
// Common CPU setup code.
static void
mpmain(void)
{
cprintf("cpu%d: starting %d\n", cpuid(), cpuid());
// cpu0,1 で同じIDTを使う
// IO/APICからの割り込みは ioapicenable(IRQ_*, <cpu>) で指定したcpuに飛ぶ
idtinit(); // load idt register
log_debug("mycpu()->started = 1");
xchg(&(mycpu()->started), 1); // tell startothers() we're up
// // IRQ_COM1 がcpu1で起きない実験
// if (cpuid() == 0) {
// for (;;)
// asm("nop");
// }
scheduler(); // start running processes
}
pde_t entrypgdir[]; // For entry.S
// Start the non-boot (AP) processors.
static void
startothers(void)
{
log_debug("");
extern uchar _binary_entryother_start[], _binary_entryother_size[];
uchar *code;
struct cpu *c;
char *stack;
// Write entry code to unused memory at 0x7000.
// The linker has placed the image of entryother.S in
// _binary_entryother_start.
code = P2V(0x7000);
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
for(c = cpus; c < cpus+ncpu; c++){
if(c == mycpu()) // We've started already.
continue;
// Tell entryother.S what stack to use, where to enter, and what
// pgdir to use. We cannot use kpgdir yet, because the AP processor
// is running in low memory, so we use entrypgdir for the APs too.
stack = kalloc();
*(void**)(code-4) = stack + KSTACKSIZE;
*(void(**)(void))(code-8) = mpenter;
*(int**)(code-12) = (void *) V2P(entrypgdir);
lapicstartap(c->apicid, V2P(code));
log_debug("wait c->started");
// wait for cpu to finish mpmain()
while(c->started == 0)
#if 0
;
#else /* 0 */
asm("nop");
#endif /* 0 */
log_debug("accept c->started == %d", c->started);
}
}
// The boot page table used in entry.S and entryother.S.
// Page directories (and page tables) must start on page boundaries,
// hence the __aligned__ attribute.
// PTE_PS in a page directory entry enables 4Mbyte pages.
// &entrypgdir 0x8010a000
// entrypgdir[0] = 163 0xa3 0b10100011
// entrypgdir[512] = 227 0xe3 0b11100011
// ^PS ^^W P
// ^^???
// VA [0, 4MB) == VA [KERNBASE, KERNBASE+4MB]
// (gdb) x/32bx 0x00000000
// 0x0: 0x53 0xff 0x00 0xf0 0x53 0xff 0x00 0xf0
// 0x8: 0xc3 0xe2 0x00 0xf0 0x53 0xff 0x00 0xf0
// 0x10: 0x53 0xff 0x00 0xf0 0x54 0xff 0x00 0xf0
// 0x18: 0x53 0xff 0x00 0xf0 0x53 0xff 0x00 0xf0
// (gdb) x/32bx 0x80000000
// 0x80000000: 0x53 0xff 0x00 0xf0 0x53 0xff 0x00 0xf0
// 0x80000008: 0xc3 0xe2 0x00 0xf0 0x53 0xff 0x00 0xf0
// 0x80000010: 0x53 0xff 0x00 0xf0 0x54 0xff 0x00 0xf0
// 0x80000018: 0x53 0xff 0x00 0xf0 0x53 0xff 0x00 0xf0
__attribute__((__aligned__(PGSIZE)))
pde_t entrypgdir[NPDENTRIES] = {
// Map VA's [0, 4MB) to PA's [0, 4MB)
// p.37 the x86's 4-megabytes "super pages" ... PTE_PS ...
[0] = (0) | PTE_P | PTE_W | PTE_PS,
// Map VA's [KERNBASE, KERNBASE+4MB) to PA's [0, 4MB)
[KERNBASE>>PDXSHIFT] = (0) | PTE_P | PTE_W | PTE_PS,
};
//PAGEBREAK!
// Blank page.
//PAGEBREAK!
// Blank page.
//PAGEBREAK!
// Blank page.
|
450694.c | /*
* Copyright (c) 2014 VMware, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* OvsTunnel.c
* WFP Classified callback function and Action code for injecting a packet to the vswitch
*/
#include "precomp.h"
#pragma warning(push)
#pragma warning(disable:4201) // unnamed struct/union
#include <fwpsk.h>
#pragma warning(pop)
#pragma warning( push )
#pragma warning( disable:4127 )
#include <fwpmk.h>
#include "Tunnel.h"
#include "Switch.h"
#include "Vport.h"
#include "Event.h"
#include "User.h"
#include "Vxlan.h"
#include "PacketIO.h"
#include "NetProto.h"
#include "Flow.h"
extern POVS_SWITCH_CONTEXT gOvsSwitchContext;
static NTSTATUS
OvsInjectPacketThroughActions(PNET_BUFFER_LIST pNbl,
OVS_TUNNEL_PENDED_PACKET *packet);
VOID OvsAcquireDatapathRead(OVS_DATAPATH *datapath,
LOCK_STATE_EX *lockState,
BOOLEAN dispatch);
VOID OvsAcquireDatapathWrite(OVS_DATAPATH *datapath,
LOCK_STATE_EX *lockState,
BOOLEAN dispatch);
VOID OvsReleaseDatapath(OVS_DATAPATH *datapath,
LOCK_STATE_EX *lockState);
NTSTATUS
OvsTunnelNotify(FWPS_CALLOUT_NOTIFY_TYPE notifyType,
const GUID *filterKey,
const FWPS_FILTER *filter)
{
UNREFERENCED_PARAMETER(notifyType);
UNREFERENCED_PARAMETER(filterKey);
UNREFERENCED_PARAMETER(filter);
return STATUS_SUCCESS;
}
static NTSTATUS
OvsTunnelAnalyzePacket(OVS_TUNNEL_PENDED_PACKET *packet)
{
NTSTATUS status = STATUS_SUCCESS;
UINT32 packetLength = 0;
ULONG bytesCopied = 0;
NET_BUFFER_LIST *copiedNBL = NULL;
NET_BUFFER *netBuffer;
NDIS_STATUS ndisStatus;
/*
* For inbound net buffer list, we can assume it contains only one
* net buffer (unless it was an re-assembeled fragments). in both cases
* the first net buffer should include all headers, we assert if the retreat fails
*/
netBuffer = NET_BUFFER_LIST_FIRST_NB(packet->netBufferList);
/* Drop the packet from the host stack */
packet->classifyOut->actionType = FWP_ACTION_BLOCK;
packet->classifyOut->rights &= ~FWPS_RIGHT_ACTION_WRITE;
/* Adjust the net buffer list offset to the start of the IP header */
ndisStatus = NdisRetreatNetBufferDataStart(netBuffer,
packet->ipHeaderSize +
packet->transportHeaderSize,
0, NULL);
ASSERT(ndisStatus == NDIS_STATUS_SUCCESS);
/* Single NBL element for WFP */
ASSERT(packet->netBufferList->Next == NULL);
/* Note that the copy will inherit the original net buffer list's offset */
packetLength = NET_BUFFER_DATA_LENGTH(netBuffer);
copiedNBL = OvsAllocateVariableSizeNBL(gOvsSwitchContext, packetLength,
OVS_DEFAULT_HEADROOM_SIZE);
if (copiedNBL == NULL) {
goto analyzeDone;
}
status = NdisCopyFromNetBufferToNetBuffer(NET_BUFFER_LIST_FIRST_NB(copiedNBL),
0, packetLength,
netBuffer, 0, &bytesCopied);
if (status != NDIS_STATUS_SUCCESS || packetLength != bytesCopied) {
goto analyzeFreeNBL;
}
status = OvsInjectPacketThroughActions(copiedNBL,
packet);
goto analyzeDone;
/* Undo the adjustment on the original net buffer list */
analyzeFreeNBL:
OvsCompleteNBL(gOvsSwitchContext, copiedNBL, TRUE);
analyzeDone:
NdisAdvanceNetBufferDataStart(netBuffer,
packet->transportHeaderSize + packet->ipHeaderSize,
FALSE,
NULL);
return status;
}
/*
* --------------------------------------------------------------------------
* This is the classifyFn function of the datagram-data callout. It
* allocates a packet structure to store the classify and meta data and
* it references the net buffer list for out-of-band modification and
* re-injection. The packet structure will be queued to the global packet
* queue. The worker thread will then be signaled, if idle, to process
* the queue.
* --------------------------------------------------------------------------
*/
VOID
OvsTunnelClassify(const FWPS_INCOMING_VALUES *inFixedValues,
const FWPS_INCOMING_METADATA_VALUES *inMetaValues,
VOID *layerData,
const VOID *classifyContext,
const FWPS_FILTER *filter,
UINT64 flowContext,
FWPS_CLASSIFY_OUT *classifyOut)
{
OVS_TUNNEL_PENDED_PACKET packetStorage;
OVS_TUNNEL_PENDED_PACKET *packet = &packetStorage;
FWP_DIRECTION direction;
UNREFERENCED_PARAMETER(classifyContext);
UNREFERENCED_PARAMETER(filter);
UNREFERENCED_PARAMETER(flowContext);
ASSERT(layerData != NULL);
/* We don't have the necessary right to alter the packet flow */
if ((classifyOut->rights & FWPS_RIGHT_ACTION_WRITE) == 0) {
/* XXX TBD revisit protect against other filters owning this packet */
ASSERT(FALSE);
goto Exit;
}
RtlZeroMemory(packet, sizeof(OVS_TUNNEL_PENDED_PACKET));
/* classifyOut cannot be accessed from a different thread context */
packet->classifyOut = classifyOut;
if (inFixedValues->layerId == FWPS_LAYER_DATAGRAM_DATA_V4) {
direction =
inFixedValues->incomingValue[FWPS_FIELD_DATAGRAM_DATA_V4_DIRECTION].\
value.uint32;
}
else {
ASSERT(inFixedValues->layerId == FWPS_LAYER_DATAGRAM_DATA_V6);
direction =
inFixedValues->incomingValue[FWPS_FIELD_DATAGRAM_DATA_V6_DIRECTION].\
value.uint32;
}
packet->netBufferList = layerData;
ASSERT(FWPS_IS_METADATA_FIELD_PRESENT(inMetaValues,
FWPS_METADATA_FIELD_COMPARTMENT_ID));
ASSERT(direction == FWP_DIRECTION_INBOUND);
ASSERT(FWPS_IS_METADATA_FIELD_PRESENT(
inMetaValues,
FWPS_METADATA_FIELD_IP_HEADER_SIZE));
ASSERT(FWPS_IS_METADATA_FIELD_PRESENT(
inMetaValues,
FWPS_METADATA_FIELD_TRANSPORT_HEADER_SIZE));
packet->ipHeaderSize = inMetaValues->ipHeaderSize;
packet->transportHeaderSize = inMetaValues->transportHeaderSize;
ASSERT(inFixedValues->incomingValue[FWPS_FIELD_DATAGRAM_DATA_V4_IP_PROTOCOL].value.uint8 == IPPROTO_UDP );
OvsTunnelAnalyzePacket(packet);
Exit:
;
}
static NTSTATUS
OvsInjectPacketThroughActions(PNET_BUFFER_LIST pNbl,
OVS_TUNNEL_PENDED_PACKET *packet)
{
NTSTATUS status = STATUS_SUCCESS;
OvsIPv4TunnelKey tunnelKey;
NET_BUFFER *pNb;
ULONG sendCompleteFlags = 0;
BOOLEAN dispatch;
PNDIS_SWITCH_FORWARDING_DETAIL_NET_BUFFER_LIST_INFO fwdDetail;
LOCK_STATE_EX lockState, dpLockState;
LIST_ENTRY missedPackets;
OvsCompletionList completionList;
KIRQL irql;
ULONG SendFlags = NDIS_SEND_FLAGS_SWITCH_DESTINATION_GROUP;
OVS_DATAPATH *datapath = NULL;
ASSERT(gOvsSwitchContext);
datapath = &gOvsSwitchContext->datapath;
/* Fill the tunnel key */
status = OvsSlowPathDecapVxlan(pNbl, &tunnelKey);
if(!NT_SUCCESS(status)) {
goto dropit;
}
pNb = NET_BUFFER_LIST_FIRST_NB(pNbl);
NdisAdvanceNetBufferDataStart(pNb,
packet->transportHeaderSize + packet->ipHeaderSize +
sizeof(VXLANHdr),
FALSE,
NULL);
/* Most likely (always) dispatch irql */
irql = KeGetCurrentIrql();
/* dispatch is used for datapath lock as well */
dispatch = (irql == DISPATCH_LEVEL) ? NDIS_RWL_AT_DISPATCH_LEVEL : 0;
if (dispatch) {
sendCompleteFlags |= NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL;
}
InitializeListHead(&missedPackets);
OvsInitCompletionList(&completionList, gOvsSwitchContext,
sendCompleteFlags);
{
POVS_VPORT_ENTRY vport;
UINT32 portNo;
OVS_PACKET_HDR_INFO layers;
OvsFlowKey key;
UINT64 hash;
PNET_BUFFER curNb;
OvsFlow *flow;
fwdDetail = NET_BUFFER_LIST_SWITCH_FORWARDING_DETAIL(pNbl);
/*
* XXX WFP packets contain a single NBL structure.
* Reassembeled packet "may" have multiple NBs, however, a simple test shows
* that the packet still has a single NB (after reassemble)
* We still need to check if the Ethernet header of the innet packet is in a single MD
*/
curNb = NET_BUFFER_LIST_FIRST_NB(pNbl);
ASSERT(curNb->Next == NULL);
NdisAcquireRWLockRead(gOvsSwitchContext->dispatchLock, &lockState, dispatch);
/* Lock the flowtable for the duration of accessing the flow */
OvsAcquireDatapathRead(datapath, &dpLockState, NDIS_RWL_AT_DISPATCH_LEVEL);
SendFlags |= NDIS_SEND_FLAGS_DISPATCH_LEVEL;
vport = OvsFindTunnelVportByDstPort(gOvsSwitchContext,
htons(tunnelKey.dst_port),
OVS_VPORT_TYPE_VXLAN);
if (vport == NULL){
status = STATUS_UNSUCCESSFUL;
goto unlockAndDrop;
}
ASSERT(vport->ovsType == OVS_VPORT_TYPE_VXLAN);
portNo = vport->portNo;
status = OvsExtractFlow(pNbl, portNo, &key, &layers, &tunnelKey);
if (status != NDIS_STATUS_SUCCESS) {
goto unlockAndDrop;
}
flow = OvsLookupFlow(datapath, &key, &hash, FALSE);
if (flow) {
OvsFlowUsed(flow, pNbl, &layers);
datapath->hits++;
OvsActionsExecute(gOvsSwitchContext, &completionList, pNbl,
portNo, SendFlags, &key, &hash, &layers,
flow->actions, flow->actionsLen);
OvsReleaseDatapath(datapath, &dpLockState);
} else {
POVS_PACKET_QUEUE_ELEM elem;
datapath->misses++;
elem = OvsCreateQueueNlPacket(NULL, 0, OVS_PACKET_CMD_MISS,
vport, &key, pNbl, curNb,
TRUE, &layers);
if (elem) {
/* Complete the packet since it was copied to user buffer. */
InsertTailList(&missedPackets, &elem->link);
OvsQueuePackets(&missedPackets, 1);
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
goto unlockAndDrop;
}
NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
}
return status;
unlockAndDrop:
OvsReleaseDatapath(datapath, &dpLockState);
NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
dropit:
pNbl = OvsCompleteNBL(gOvsSwitchContext, pNbl, TRUE);
ASSERT(pNbl == NULL);
return status;
}
#pragma warning(pop)
|
862953.c | /*++
Copyright (c) 2004, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
S3Resume.c
Abstract:
Boot Script Executer PPI GUID as defined in Tiano
--*/
#include "Tiano.h"
#include "PeiBind.h"
#include "PeiApi.h"
#include EFI_PPI_DEFINITION (S3Resume)
EFI_GUID gPeiS3ResumePpiGuid = PEI_S3_RESUME_PPI_GUID;
EFI_GUID_STRING(&gPeiS3ResumePpiGuid, "S3Resume", "S3 Resume PPI");
|
257262.c | //jiuyin-baiguzhao.c 九陰白骨爪
#include <ansi.h>;
inherit SKILL;
string type() { return "martial"; }
string martialtype() { return "skill"; }
mapping *action = ({
([ "action": "$N左爪虛晃，右爪蓄力，一招「勾魂奪魄」直插向$n的$l",
"force" : 250,
"attack": 45,
"dodge" : 10,
"parry" : 18,
"damage": 30,
"lvl" : 0,
"skill_name" : "勾魂奪魄" ,
"damage_type" : "抓傷"
]),
([ "action": "$N雙手連環成爪，爪爪鈎向$n，「九子連環」已向$n的$l抓出",
"force" : 270,
"attack": 50,
"dodge" : 20,
"parry" : 26,
"damage": 45,
"lvl" : 40,
"skill_name" : "九子連環" ,
"damage_type" : "抓傷"
]),
([ "action": "$N雙手使出「十指穿心」，招招不離$n的$l",
"force" : 300,
"attack": 60,
"dodge" : 20,
"parry" : 32,
"damage": 45,
"lvl" : 70,
"skill_name" : "九子連環" ,
"damage_type" : "抓傷"
]),
([ "action": "$N身形圍$n一轉，使出「天羅地網」，$n的$l已完全籠罩在爪影下",
"force" : 340,
"attack": 85,
"dodge" : 30,
"parry" : 55,
"damage": 55,
"lvl" : 100,
"skill_name" : "天羅地網" ,
"damage_type" : "抓傷"
]),
([ "action": "$N使一招「風捲殘雲」，雙爪幻出滿天爪影抓向$n全身",
"force" : 370,
"attack": 110,
"dodge" : 40,
"parry" : 68,
"damage": 70,
"lvl" : 130,
"skill_name" : "風捲殘雲" ,
"damage_type" : "抓傷"
]),
([ "action": "$N吐氣揚聲，一招「唯我獨尊」雙爪奮力向$n天靈戳下",
"force" : 420,
"attack": 140,
"dodge" : 50,
"parry" : 85,
"damage": 90,
"lvl" : 160,
"skill_name" : "唯我獨尊" ,
"damage_type" : "抓傷"
]),
});
int valid_enable(string usage) { return usage=="claw" || usage=="parry"; }
int valid_combine(string combo) { return combo=="cuixin-zhang"; }
int valid_learn(object me)
{
if( query("character", me) != "心狠手辣" && query("character", me) != "國士無雙" )
return notify_fail("你天性不符，受其拘束，無法領會九陰白骨爪的妙旨。\n");
if( query_temp("weapon", me) || query_temp("secondary_weapon", me) )
return notify_fail("練九陰白骨爪必須空手。\n");
if( query("max_neili", me)<800 )
return notify_fail("你的內力太弱，無法練九陰白骨爪。\n");
if ((int)me->query_str() < 30)
return notify_fail("你現在膂力孱弱，還無法練九陰白骨爪。\n");
if ((int)me->query_skill("force") < 90)
return notify_fail("你的內功太差，無法練九陰白骨爪。\n");
if ((int)me->query_skill("claw", 1) < 60)
return notify_fail("你的基本爪法太差，無法領會九陰白骨爪。\n");
if ((int)me->query_skill("claw", 1) < (int)me->query_skill("jiuyin-baiguzhao", 1))
return notify_fail("你的基本爪法火候不夠，無法領會更高深的九陰白骨爪。\n");
return 1;
}
int practice_skill(object me)
{
object obj;
object *obs;
int i, skill, damage;
skill = me->query_skill("jiuyin-baiguzhao", 1);
if( query("qi", me)<100 )
return notify_fail("你的體力太低了。\n");
if( query("neili", me)<500 )
return notify_fail("你的內力不夠練九陰白骨爪。\n");
if( query("no_fight", environment(me)) )
return notify_fail("這裏不能練功。\n");
if( query("sleep_room", environment(me)) )
return notify_fail("這裏練功會打擾別人休息。\n");
if (skill < 200)
{
obs = filter_array(all_inventory(environment(me)),
(: (base_name($1) == CORPSE_OB &&
!query("been_cut/head", $1) ||
base_name($1) == "/clone/misc/head") &&
query_temp("clawed_by_jiuyin", $1)<10:));
if (sizeof(obs) < 1)
return notify_fail("練九陰白骨抓需有屍體或是完好的頭蓋骨。\n");
addn("neili", -450, me);
}
me->receive_damage("qi", 80);
addn("neili", -40, me);
if (skill < 200)
{
message_vision(HIB "只見$N" HIB "左手上圈下鈎、左旋右轉，連變了"
"七八般花樣，驀地裏右手一伸，噗的一響，五根手指直"
"插入\n頭骨的腦門。隨後五根手指" HIR "血淋淋"
HIB "的提將起來。\n" NOR, me);
if (base_name(obs[0]) == "/clone/misc/head")
obs[0]->set("long",query("long", obs[0])+
"上面赫然有五個小洞，伸手一探，剛好可以插入。\n");
addn_temp("clawed_by_jiuyin", 1, obs[0]);
me->improve_skill("jiuyin-baiguzhao", 100 + skill * 5 + random(500));
}
return 1;
}
string query_skill_name(int level)
{
int i;
for(i = sizeof(action); i > 0; i--)
if(level >= action[i-1]["lvl"])
return action[i-1]["skill_name"];
}
mapping query_action(object me, object weapon)
{
/* d_e=dodge_effect p_e=parry_effect f_e=force_effect m_e=damage_effect */
int d_e1 = 20;
int d_e2 = 5;
int p_e1 = -20;
int p_e2 = -60;
int f_e1 = 300;
int f_e2 = 600;
int i, lvl, seq, ttl = sizeof(action);
seq = random(ttl); /* 選擇出手招數序號 */
return ([
"action" : action[seq]["action"],
"dodge" : d_e1 + (d_e2 - d_e1) * seq / ttl,
"parry" : p_e1 + (p_e2 - p_e1) * seq / ttl,
"force" : f_e1 + (f_e2 - f_e1) * seq / ttl,
"damage_type" : random(2) ? "抓傷" : "內傷",
]);
}
int learn_bonus() { return 0; }
int practice_bonus() { return 0; }
int success() { return 5; }
int power_point(object me)
{
if( query("shen", me) <= -100000)return 1;
else if( query("shen", me)<0)return 0.8;
else return 0.6;
}
void skill_improved(object me)
{
tell_object(me, HIR"你忽然從心底生出一股惡念：殺、殺、殺！我要殺絕天下人！\n" NOR );
addn("shen", -200, me);
}
mixed hit_ob(object me, object victim, int damage_bonus)
{
int lvl;
int flvl;
mixed result;
lvl = me->query_skill("jiuyin-baiguzhao", 1);
flvl=query("jiali", me);
if (lvl < 80 || flvl < 10 || ! damage_bonus)
return;
if (damage_bonus / 2 > victim->query_str())
{
victim->affect_by("jy_poison",
([ "level" : flvl + random(flvl),
"id":query("id", me),
"duration" : lvl / 100 + random(lvl / 10) ]));
result = ([ "damage" : damage_bonus ]);
result += ([ "msg" : HIR "你聽到「喀啦」一聲輕響，竟似是骨碎的聲音！\n" NOR ]);
return result;
}
}
int query_effect_parry(object attacker, object me)
{
int lvl;
if( objectp(query_temp("weapon", me)) )
return 0;
lvl = me->query_skill("jiuyin-baiguzhao", 1);
if (lvl < 80) return 0;
if (lvl < 200) return 50;
if (lvl < 280) return 80;
if (lvl < 350) return 100;
return 120;
}
string perform_action_file(string action)
{
return __DIR__"jiuyin-baiguzhao/" + action;
}
int help(object me)
{
write(HIC"\n九陰白骨爪："NOR"\n");
write(@HELP
徽宗皇帝於政和年間，遍搜普天下道家之書，雕版印行，一共
有五千四百八十一卷，稱為‘萬壽道藏’。皇帝委派刻書之人，叫
做黃裳。他生怕這部大道藏刻錯了字，皇帝發覺之後不免要殺他的
頭，因此上一卷一卷的細心校讀。他居然便因此精通道學，更因此
而悟得了武功中的高深道理。他無師自通，修習內功外功，竟成為
一位武功大高手。他因此涉及江湖仇殺，退隱山林。不知不覺竟已
過了四十多年，終於對每一個敵人所使過的招數，他都想通了破解
的法子對付。於是出得山來，去報仇雪恨。不料那些敵人全都已不
在人世了。黃裳心想：‘原來我也老了，可也沒幾年好活啦。’他
花了這幾十年心血，想出了包含普天下各家各派功夫的武學，過得
幾年，這番心血豈不是就此湮沒？於是他將所想到的法門寫成了上
下兩卷書，那就是《九陰真經》。九陰白骨爪就是依此書練成的霸
道功夫。
學習要求：
內力200
HELP
);
return 1;
}
|
558569.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tglory <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/10/26 17:55:21 by tglory #+# #+# */
/* Updated: 2020/10/26 17:55:21 by tglory ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
return (c + 'A' - 'a');
else
return (c);
}
|
270524.c | inherit "room/room";
reset(arg) {
add_exit("south", "/wizards/ahma/orc/forest/for12");
add_exit("west", "/wizards/ahma/orc/forest/for15");
add_exit("southwest", "/wizards/ahma/orc/forest/for14");
short_desc = "On a small opening";
long_desc = "The green, grassy opening is full of life. Animals wander near the\n" +
"edges of the opening, looking for food and ready to run into the forest\n" +
"if something would threaten them. The flowers sway a bit in the gentle\n" +
"breezes of wind, resonating the life force within them. Birds sing their\n" +
"songs on the brances of trees on the edge of the meadow. A small wooden\n" +
"cottage can be seen behind a short distance to west.\n";
items = allocate(4);
items[0] = "flowers";
items[1] = "Commonly seen flowers like dandelions are growing here. You do not\n" +
"want to examine them more than a glance because you really do see\n" +
"them everywhere when moving around";
items[2] = "animals";
items[3] = "Few wild forest animals are wandering around the opening. Maybe they\n" +
"are looking something to eat. The animals are aware of your presence\n" +
"so it would be a waste of time trying to catch or kill them";
}
init() {
::init();
add_action("hep", "pick");
if(!random(250)) {
tell_room(this_object(), "An Orcish ranger jumps out from the bush.\n");
move_object(clone_object("/wizards/ahma/orc/mob/ranger"), this_object());
}
}
hep(str) {
if(str == "flowers" || str == "dandelions") {
write("You do not want to pick that common flowers like dandelions right now.\n");
return 1;
}
else {
return;
}
}
|
379551.c | __attribute__((__constructor__)) void test_constructor() {}
|
139703.c | /*
* Purpose: Test bcp in and out, and specifically bcp_colfmt()
* Functions: bcp_colfmt bcp_columns bcp_exec bcp_init
*/
#include "common.h"
static int failed = 0;
static void
failure(const char *fmt, ...)
{
va_list ap;
failed = 1;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
#define INFILE_NAME "t0016"
#define TABLE_NAME "#dblib0016"
static void test_file(const char *fn);
static int compare_files(const char *fn1, const char *fn2);
static unsigned count_file_rows(FILE *f);
static DBPROCESS *dbproc;
int
main(int argc, char *argv[])
{
LOGINREC *login;
char in_file[30];
unsigned int n;
setbuf(stdout, NULL);
setbuf(stderr, NULL);
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
BCP_SETL(login, TRUE);
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0016");
DBSETLCHARSET(login, "UTF-8");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
printf("After logon\n");
strcpy(in_file, INFILE_NAME);
for (n = 1; n <= 100; ++n) {
test_file(in_file);
sprintf(in_file, "%s_%d", INFILE_NAME, n);
if (sql_reopen(in_file) != SUCCEED)
break;
}
dbclose(dbproc);
dbexit();
printf("dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
static int got_error = 0;
static int
ignore_msg_handler(DBPROCESS * dbproc, DBINT msgno, int state, int severity, char *text, char *server, char *proc, int line)
{
got_error = 1;
return 0;
}
static int
ignore_err_handler(DBPROCESS * dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr)
{
got_error = 1;
return INT_CANCEL;
}
static char line1[1024*16];
static char line2[1024*16];
static void
test_file(const char *fn)
{
int i;
RETCODE ret;
int num_cols = 0;
const char *out_file = "t0016.out";
const char *err_file = "t0016.err";
DBINT rows_copied;
unsigned num_rows = 2;
FILE *input_file;
char in_file[256];
snprintf(in_file, sizeof(in_file), "%s/%s.in", FREETDS_SRCDIR, fn);
input_file = fopen(in_file, "rb");
if (!input_file) {
sprintf(in_file, "%s.in", fn);
input_file = fopen(in_file, "rb");
}
if (!input_file) {
fprintf(stderr, "could not open %s\n", in_file);
exit(1);
}
num_rows = count_file_rows(input_file);
fclose(input_file);
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("Creating table '%s'\n", TABLE_NAME);
got_error = 0;
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS)
continue;
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
if (got_error)
return;
/* BCP in */
printf("bcp_init with in_file as '%s'\n", in_file);
ret = bcp_init(dbproc, TABLE_NAME, in_file, err_file, DB_IN);
if (ret != SUCCEED)
failure("bcp_init failed\n");
printf("return from bcp_init = %d\n", ret);
ret = sql_cmd(dbproc);
printf("return from dbcmd = %d\n", ret);
ret = dbsqlexec(dbproc);
printf("return from dbsqlexec = %d\n", ret);
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
printf("Number of columns = %d\n", num_cols);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
ret = bcp_columns(dbproc, num_cols);
if (ret != SUCCEED)
failure("bcp_columns failed\n");
printf("return from bcp_columns = %d\n", ret);
for (i = 1; i < num_cols; i++) {
if ((ret = bcp_colfmt(dbproc, i, SYBCHAR, 0, -1, (const BYTE *) "\t", sizeof(char), i)) == FAIL)
failure("return from bcp_colfmt = %d\n", ret);
}
if ((ret = bcp_colfmt(dbproc, num_cols, SYBCHAR, 0, -1, (const BYTE *) "\n", sizeof(char), num_cols)) == FAIL)
failure("return from bcp_colfmt = %d\n", ret);
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != num_rows)
failure("bcp_exec failed\n");
printf("%d rows copied in\n", rows_copied);
/* BCP out */
rows_copied = 0;
ret = bcp_init(dbproc, TABLE_NAME, out_file, err_file, DB_OUT);
if (ret != SUCCEED)
failure("bcp_int failed\n");
printf("select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
ret = bcp_columns(dbproc, num_cols);
for (i = 1; i < num_cols; i++) {
if ((ret = bcp_colfmt(dbproc, i, SYBCHAR, 0, -1, (const BYTE *) "\t", sizeof(char), i)) == FAIL)
failure("return from bcp_colfmt = %d\n", ret);
}
if ((ret = bcp_colfmt(dbproc, num_cols, SYBCHAR, 0, -1, (const BYTE *) "\n", sizeof(char), num_cols)) == FAIL)
failure("return from bcp_colfmt = %d\n", ret);
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != num_rows)
failure("bcp_exec failed\n");
printf("%d rows copied out\n", rows_copied);
printf("Dropping table '%s'\n", TABLE_NAME);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS)
continue;
if (failed)
return;
if (compare_files(in_file, out_file))
printf("Input and output files are equal\n");
else
failed = 1;
}
static size_t fgets_raw(char *s, int len, FILE *f)
{
char *p = s;
while (len > 1) {
int c = getc(f);
if (c == EOF) {
if (ferror(f))
return 0;
break;
}
*p++ = c;
--len;
if (c == '\n')
break;
}
if (len > 0)
*p = 0;
return p - s;
}
static int compare_files(const char *fn1, const char *fn2)
{
int equal = 1;
FILE *f1, *f2;
size_t s1, s2;
/* check input and output should be the same */
f1 = fopen(fn1, "r");
f2 = fopen(fn2, "r");
if (f1 != NULL && f2 != NULL) {
int line = 1;
for (;; ++line) {
s1 = fgets_raw(line1, sizeof(line1), f1);
s2 = fgets_raw(line2, sizeof(line2), f2);
/* EOF or error of one */
if (!!s1 != !!s2) {
equal = 0;
failure("error reading a file or EOF of a file\n");
break;
}
/* EOF or error of both */
if (!s1) {
if (feof(f1) && feof(f2))
break;
equal = 0;
failure("error reading a file\n");
break;
}
if (s1 != s2 || memcmp(line1, line2, s1) != 0) {
equal = 0;
failure("File different at line %d\n"
" input: %s"
" output: %s",
line, line1, line2);
}
}
} else {
equal = 0;
failure("error opening files\n");
}
if (f1)
fclose(f1);
if (f2)
fclose(f2);
return equal;
}
static unsigned count_file_rows(FILE *f)
{
size_t s;
unsigned rows = 1;
char last = '\n';
assert(f);
while ((s = fgets_raw(line1, sizeof(line1), f)) != 0) {
last = line1[s-1];
if (last == '\n')
++rows;
}
if (last == '\n')
--rows;
assert(!ferror(f));
return rows;
}
|
497494.c | /*
* msvcrt.dll mbcs functions
*
* Copyright 1999 Alexandre Julliard
* Copyright 2000 Jon Griffths
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* FIXME
* Not currently binary compatible with win32. MSVCRT_mbctype must be
* populated correctly and the ismb* functions should reference it.
*/
#include <stdio.h>
#include <limits.h>
#include <mbctype.h>
#include <mbstring.h>
#include "msvcrt.h"
#include "mtdll.h"
#include "winnls.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
unsigned char MSVCRT_mbctype[257] = { 0 };
/* It seems that the data about valid trail bytes is not available from kernel32
* so we have to store is here. The format is the same as for lead bytes in CPINFO */
struct cp_extra_info_t
{
int cp;
BYTE TrailBytes[MAX_LEADBYTES];
};
static struct cp_extra_info_t g_cpextrainfo[] =
{
{932, {0x40, 0x7e, 0x80, 0xfc, 0, 0}},
{936, {0x40, 0xfe, 0, 0}},
{949, {0x41, 0xfe, 0, 0}},
{950, {0x40, 0x7e, 0xa1, 0xfe, 0, 0}},
{1361, {0x31, 0x7e, 0x81, 0xfe, 0, 0}},
{20932, {1, 255, 0, 0}}, /* seems to give different results on different systems */
{0, {1, 255, 0, 0}} /* match all with FIXME */
};
/* Maps cp932 single byte character to multi byte character */
static const unsigned char mbbtombc_932[] = {
0x40,0x49,0x68,0x94,0x90,0x93,0x95,0x66,0x69,0x6a,0x96,0x7b,0x43,0x7c,0x44,0x5e,
0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x46,0x47,0x83,0x81,0x84,0x48,
0x97,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x76,
0x77,0x78,0x79,0x6d,0x8f,0x6e,0x4f,0x51,0x65,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0x95,0x50,
0x42,0x75,0x76,0x41,0x45,0x92,0x40,0x42,0x44,0x46,0x48,0x83,0x85,0x87,0x62,
0x5b,0x41,0x43,0x45,0x47,0x49,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,
0x5e,0x60,0x63,0x65,0x67,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x71,0x74,0x77,0x7a,0x7d,
0x7e,0x80,0x81,0x82,0x84,0x86,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8f,0x93,0x4a,0x4b };
/* Maps multibyte cp932 punctuation marks to single byte equivalents */
static const unsigned char mbctombb_932_punct[] = {
0x20,0xa4,0xa1,0x2c,0x2e,0xa5,0x3a,0x3b,0x3f,0x21,0xde,0xdf,0x00,0x00,0x00,0x5e,
0x7e,0x5f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x00,0x00,0x2f,0x00,
0x00,0x00,0x7c,0x00,0x00,0x60,0x27,0x00,0x22,0x28,0x29,0x00,0x00,0x5b,0x5d,0x7b,
0x7d,0x00,0x00,0x00,0x00,0xa2,0xa3,0x00,0x00,0x00,0x00,0x2b,0x2d,0x00,0x00,0x00,
0x00,0x3d,0x00,0x3c,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5c,
0x24,0x00,0x00,0x25,0x23,0x26,0x2a,0x40};
/* Maps multibyte cp932 hiragana/katakana to single-byte equivalents */
static const unsigned char mbctombb_932_kana[] = {
0xa7,0xb1,0xa8,0xb2,0xa9,0xb3,0xaa,0xb4,0xab,0xb5,0xb6,0xb6,0xb7,0xb7,0xb8,0xb8,
0xb9,0xb9,0xba,0xba,0xbb,0xbb,0xbc,0xbc,0xbd,0xbd,0xbe,0xbe,0xbf,0xbf,0xc0,0xc0,
0xc1,0xc1,0xaf,0xc2,0xc2,0xc3,0xc3,0xc4,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xca,
0xca,0xcb,0xcb,0xcb,0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xd0,0xd1,
0xd2,0xd3,0xac,0xd4,0xad,0xd5,0xae,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xb2,
0xb4,0xa6,0xdd,0xb3,0xb6,0xb9};
static wchar_t msvcrt_mbc_to_wc_l(unsigned int ch, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
wchar_t chW;
char mbch[2];
int n_chars;
if(locale)
mbcinfo = locale->mbcinfo;
else
mbcinfo = get_mbcinfo();
if (ch <= 0xff) {
mbch[0] = ch;
n_chars = 1;
} else {
mbch[0] = (ch >> 8) & 0xff;
mbch[1] = ch & 0xff;
n_chars = 2;
}
if (!MultiByteToWideChar(mbcinfo->mbcodepage, 0, mbch, n_chars, &chW, 1))
{
WARN("MultiByteToWideChar failed on %x\n", ch);
return 0;
}
return chW;
}
static wchar_t msvcrt_mbc_to_wc(unsigned int ch)
{
return msvcrt_mbc_to_wc_l(ch, NULL);
}
static inline size_t u_strlen( const unsigned char *str )
{
return strlen( (const char*) str );
}
static inline unsigned char* u_strncat( unsigned char* dst, const unsigned char* src, size_t len )
{
return (unsigned char*)strncat( (char*)dst, (const char*)src, len);
}
static inline int u_strcmp( const unsigned char *s1, const unsigned char *s2 )
{
return strcmp( (const char*)s1, (const char*)s2 );
}
static inline int u_strcasecmp( const unsigned char *s1, const unsigned char *s2 )
{
return _stricmp( (const char*)s1, (const char*)s2 );
}
static inline int u_strncmp( const unsigned char *s1, const unsigned char *s2, size_t len )
{
return strncmp( (const char*)s1, (const char*)s2, len );
}
static inline int u_strncasecmp( const unsigned char *s1, const unsigned char *s2, size_t len )
{
return _strnicmp( (const char*)s1, (const char*)s2, len );
}
static inline unsigned char *u_strchr( const unsigned char *s, unsigned char x )
{
return (unsigned char*) strchr( (const char*)s, x );
}
static inline unsigned char *u_strrchr( const unsigned char *s, unsigned char x )
{
return (unsigned char*) strrchr( (const char*)s, x );
}
static inline unsigned char *u__strset( unsigned char *s, unsigned char c )
{
return (unsigned char*) _strset( (char*)s, c);
}
static inline unsigned char *u__strnset( unsigned char *s, unsigned char c, size_t len )
{
return (unsigned char*) _strnset( (char*)s, c, len );
}
/*********************************************************************
* __p__mbctype (MSVCRT.@)
*/
unsigned char* CDECL __p__mbctype(void)
{
return get_mbcinfo()->mbctype;
}
/*********************************************************************
* __p___mb_cur_max(MSVCRT.@)
*/
int* CDECL __p___mb_cur_max(void)
{
return &get_locinfo()->mb_cur_max;
}
/*********************************************************************
* ___mb_cur_max_func(MSVCRT.@)
*/
int CDECL ___mb_cur_max_func(void)
{
return get_locinfo()->mb_cur_max;
}
#if _MSVCR_VER>=80
/*********************************************************************
* ___mb_cur_max_l_func (MSVCR80.@)
*/
int CDECL ___mb_cur_max_l_func(_locale_t locale)
{
pthreadlocinfo locinfo;
if(!locale)
locinfo = get_locinfo();
else
locinfo = locale->locinfo;
return locinfo->mb_cur_max;
}
#endif
threadmbcinfo* create_mbcinfo(int cp, LCID lcid, threadmbcinfo *old_mbcinfo)
{
threadmbcinfo *mbcinfo;
int newcp;
CPINFO cpi;
BYTE *bytes;
WORD chartypes[256];
char bufA[256];
WCHAR bufW[256], lowW[256], upW[256];
int charcount, maxchar;
int ret;
int i;
if(old_mbcinfo && cp==old_mbcinfo->mbcodepage
&& (lcid==-1 || lcid==old_mbcinfo->mblcid)) {
InterlockedIncrement(&old_mbcinfo->refcount);
return old_mbcinfo;
}
mbcinfo = malloc(sizeof(threadmbcinfo));
if(!mbcinfo)
return NULL;
mbcinfo->refcount = 1;
switch (cp)
{
case _MB_CP_ANSI:
newcp = GetACP();
break;
case _MB_CP_OEM:
newcp = GetOEMCP();
break;
case _MB_CP_LOCALE:
newcp = get_locinfo()->lc_codepage;
if(newcp)
break;
/* fall through (C locale) */
case _MB_CP_SBCS:
newcp = 20127; /* ASCII */
break;
default:
newcp = cp;
break;
}
if(lcid == -1) {
sprintf(bufA, ".%d", newcp);
mbcinfo->mblcid = locale_to_LCID(bufA, NULL, NULL);
} else {
mbcinfo->mblcid = lcid;
}
if(mbcinfo->mblcid == -1)
{
WARN("Can't assign LCID to codepage (%d)\n", mbcinfo->mblcid);
mbcinfo->mblcid = 0;
}
if (!GetCPInfo(newcp, &cpi))
{
WARN("Codepage %d not found\n", newcp);
free(mbcinfo);
return NULL;
}
/* setup the _mbctype */
memset(mbcinfo->mbctype, 0, sizeof(unsigned char[257]));
memset(mbcinfo->mbcasemap, 0, sizeof(unsigned char[256]));
bytes = cpi.LeadByte;
while (bytes[0] || bytes[1])
{
for (i = bytes[0]; i <= bytes[1]; i++)
mbcinfo->mbctype[i + 1] |= _M1;
bytes += 2;
}
if (cpi.MaxCharSize == 2)
{
/* trail bytes not available through kernel32 but stored in a structure in msvcrt */
struct cp_extra_info_t *cpextra = g_cpextrainfo;
mbcinfo->ismbcodepage = 1;
while (TRUE)
{
if (cpextra->cp == 0 || cpextra->cp == newcp)
{
if (cpextra->cp == 0)
FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
bytes = cpextra->TrailBytes;
while (bytes[0] || bytes[1])
{
for (i = bytes[0]; i <= bytes[1]; i++)
mbcinfo->mbctype[i + 1] |= _M2;
bytes += 2;
}
break;
}
cpextra++;
}
}
else
mbcinfo->ismbcodepage = 0;
maxchar = (newcp == CP_UTF8) ? 128 : 256;
/* we can't use GetStringTypeA directly because we don't have a locale - only a code page
*/
charcount = 0;
for (i = 0; i < maxchar; i++)
if (!(mbcinfo->mbctype[i + 1] & _M1))
bufA[charcount++] = i;
ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
if (ret != charcount)
{
ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%ld\n",
newcp, ret, charcount, GetLastError());
}
GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
LCMapStringW(lcid, LCMAP_LOWERCASE, bufW, charcount, lowW, charcount);
LCMapStringW(lcid, LCMAP_UPPERCASE, bufW, charcount, upW, charcount);
charcount = 0;
for (i = 0; i < maxchar; i++)
if (!(mbcinfo->mbctype[i + 1] & _M1))
{
if (chartypes[charcount] & C1_UPPER)
{
mbcinfo->mbctype[i + 1] |= _SBUP;
bufW[charcount] = lowW[charcount];
}
else if (chartypes[charcount] & C1_LOWER)
{
mbcinfo->mbctype[i + 1] |= _SBLOW;
bufW[charcount] = upW[charcount];
}
charcount++;
}
ret = WideCharToMultiByte(newcp, 0, bufW, charcount, bufA, charcount, NULL, NULL);
if (ret != charcount)
{
ERR("WideCharToMultiByte failed for cp %d, ret=%d (exp %d), error=%ld\n",
newcp, ret, charcount, GetLastError());
}
charcount = 0;
for (i = 0; i < maxchar; i++)
{
if(!(mbcinfo->mbctype[i + 1] & _M1))
{
if(mbcinfo->mbctype[i] & (C1_UPPER|C1_LOWER))
mbcinfo->mbcasemap[i] = bufA[charcount];
charcount++;
}
}
if (newcp == 932) /* CP932 only - set _MP and _MS */
{
/* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
* and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
* it hard. As this is set only for codepage 932 we hardcode it what gives
* also faster execution.
*/
for (i = 161; i <= 165; i++)
mbcinfo->mbctype[i + 1] |= _MP;
for (i = 166; i <= 223; i++)
mbcinfo->mbctype[i + 1] |= _MS;
}
mbcinfo->mbcodepage = newcp;
return mbcinfo;
}
/*********************************************************************
* _setmbcp (MSVCRT.@)
*/
int CDECL _setmbcp(int cp)
{
thread_data_t *data = msvcrt_get_thread_data();
threadmbcinfo *mbcinfo;
mbcinfo = create_mbcinfo(cp, -1, get_mbcinfo());
if(!mbcinfo)
{
*_errno() = EINVAL;
return -1;
}
if(data->locale_flags & LOCALE_THREAD)
{
if(data->locale_flags & LOCALE_FREE)
free_mbcinfo(data->mbcinfo);
data->mbcinfo = mbcinfo;
}
else
{
_lock(_MB_CP_LOCK);
free_mbcinfo(MSVCRT_locale->mbcinfo);
MSVCRT_locale->mbcinfo = mbcinfo;
memcpy(MSVCRT_mbctype, MSVCRT_locale->mbcinfo->mbctype, sizeof(MSVCRT_mbctype));
_unlock(_MB_CP_LOCK);
}
return 0;
}
/*********************************************************************
* _getmbcp (MSVCRT.@)
*/
int CDECL _getmbcp(void)
{
return get_mbcinfo()->mbcodepage;
}
/*********************************************************************
* _mbsnextc_l(MSVCRT.@)
*/
unsigned int CDECL _mbsnextc_l(const unsigned char* str, _locale_t locale)
{
if(_ismbblead_l(*str, locale))
return *str << 8 | str[1];
return *str;
}
/*********************************************************************
* _mbsnextc(MSVCRT.@)
*/
unsigned int CDECL _mbsnextc(const unsigned char* str)
{
return _mbsnextc_l(str, NULL);
}
/*********************************************************************
* _mbctolower(MSVCRT.@)
*/
unsigned int CDECL _mbctolower(unsigned int c)
{
if (_ismbblead(c))
{
FIXME("Handle MBC chars\n");
return c;
}
return _tolower_l(c, NULL); /* ASCII CP or SB char */
}
/*********************************************************************
* _mbctoupper(MSVCRT.@)
*/
unsigned int CDECL _mbctoupper(unsigned int c)
{
if (_ismbblead(c))
{
FIXME("Handle MBC chars\n");
return c;
}
return _toupper_l(c, NULL); /* ASCII CP or SB char */
}
/*********************************************************************
* _mbctombb (MSVCRT.@)
*/
unsigned int CDECL _mbctombb(unsigned int c)
{
unsigned int value;
if(get_mbcinfo()->mbcodepage == 932)
{
if(c >= 0x829f && c <= 0x82f1) /* Hiragana */
return mbctombb_932_kana[c - 0x829f];
if(c >= 0x8340 && c <= 0x8396 && c != 0x837f) /* Katakana */
return mbctombb_932_kana[c - 0x8340 - (c >= 0x837f ? 1 : 0)];
if(c >= 0x8140 && c <= 0x8197) /* Punctuation */
{
value = mbctombb_932_punct[c - 0x8140];
return value ? value : c;
}
if((c >= 0x824f && c <= 0x8258) || /* Fullwidth digits */
(c >= 0x8260 && c <= 0x8279)) /* Fullwidth capitals letters */
return c - 0x821f;
if(c >= 0x8281 && c <= 0x829a) /* Fullwidth small letters */
return c - 0x8220;
/* all other cases return c */
}
return c;
}
/*********************************************************************
* _mbcjistojms(MSVCRT.@)
*
* Converts a jis character to sjis.
* Based on description from
* http://www.slayers.ne.jp/~oouchi/code/jistosjis.html
*/
unsigned int CDECL _mbcjistojms(unsigned int c)
{
/* Conversion takes place only when codepage is 932.
In all other cases, c is returned unchanged */
if(get_mbcinfo()->mbcodepage == 932)
{
if(HIBYTE(c) >= 0x21 && HIBYTE(c) <= 0x7e &&
LOBYTE(c) >= 0x21 && LOBYTE(c) <= 0x7e)
{
if(HIBYTE(c) % 2)
c += 0x1f;
else
c += 0x7d;
if(LOBYTE(c) >= 0x7F)
c += 0x1;
c = (((HIBYTE(c) - 0x21)/2 + 0x81) << 8) | LOBYTE(c);
if(HIBYTE(c) > 0x9f)
c += 0x4000;
}
else
return 0; /* Codepage is 932, but c can't be converted */
}
return c;
}
/*********************************************************************
* _mbcjmstojis(MSVCRT.@)
*
* Converts a sjis character to jis.
*/
unsigned int CDECL _mbcjmstojis(unsigned int c)
{
/* Conversion takes place only when codepage is 932.
In all other cases, c is returned unchanged */
if(get_mbcinfo()->mbcodepage == 932)
{
if(_ismbclegal(c) && HIBYTE(c) < 0xf0)
{
if(HIBYTE(c) >= 0xe0)
c -= 0x4000;
c = (((HIBYTE(c) - 0x81)*2 + 0x21) << 8) | LOBYTE(c);
if(LOBYTE(c) > 0x7f)
c -= 0x1;
if(LOBYTE(c) > 0x9d)
c += 0x83;
else
c -= 0x1f;
}
else
return 0; /* Codepage is 932, but c can't be converted */
}
return c;
}
/*********************************************************************
* _mbsdec(MSVCRT.@)
*/
unsigned char* CDECL _mbsdec(const unsigned char* start, const unsigned char* cur)
{
if(start >= cur)
return NULL;
if(get_mbcinfo()->ismbcodepage)
return (unsigned char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
return (unsigned char *)cur - 1; /* ASCII CP or SB char */
}
/*********************************************************************
* _mbclen(MSVCRT.@)
*/
size_t CDECL _mbclen(const unsigned char* str)
{
return _ismbblead(*str) ? 2 : 1;
}
/*********************************************************************
* _mbsinc(MSVCRT.@)
*/
unsigned char* CDECL _mbsinc(const unsigned char* str)
{
return (unsigned char *)(str + _mbclen(str));
}
/*********************************************************************
* _mbsninc(MSVCRT.@)
*/
unsigned char* CDECL _mbsninc(const unsigned char* str, size_t num)
{
if(!str)
return NULL;
while (num > 0 && *str)
{
if (_ismbblead(*str))
{
if (!*(str+1))
break;
str++;
}
str++;
num--;
}
return (unsigned char*)str;
}
/*********************************************************************
* _mbsnlen_l(MSVCRT.@)
*/
size_t CDECL _mbsnlen_l(const unsigned char *str,
size_t maxsize, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
size_t i = 0, len = 0;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(!mbcinfo->ismbcodepage)
return strnlen((const char*)str, maxsize);
while(i<maxsize && str[i])
{
if (_ismbblead_l(str[i], locale))
{
i++;
if (!str[i]) /* count only full chars */
break;
}
i++;
len++;
}
return i < maxsize ? len : maxsize;
}
/*********************************************************************
* _mbslen(MSVCRT.@)
*/
size_t CDECL _mbslen(const unsigned char* str)
{
return _mbsnlen_l(str, -1, NULL);
}
/*********************************************************************
* _mbslen_l(MSVCRT.@)
*/
size_t CDECL _mbslen_l(const unsigned char* str, _locale_t locale)
{
return _mbsnlen_l(str, -1, locale);
}
/*********************************************************************
* _mbsnlen(MSVCRT.@)
*/
size_t CDECL _mbsnlen(const unsigned char* str, size_t maxsize)
{
return _mbsnlen_l(str, maxsize, NULL);
}
/*********************************************************************
* _mbccpy_s_l(MSVCRT.@)
*/
int CDECL _mbccpy_s_l(unsigned char* dest, size_t maxsize,
int *copied, const unsigned char* src, _locale_t locale)
{
if(copied) *copied = 0;
if(!MSVCRT_CHECK_PMT(dest != NULL && maxsize >= 1)) return EINVAL;
dest[0] = 0;
if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
if(_ismbblead_l(*src, locale)) {
if(!src[1]) {
if(copied) *copied = 1;
*_errno() = EILSEQ;
return EILSEQ;
}
if(maxsize < 2) {
MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
return ERANGE;
}
*dest++ = *src++;
*dest = *src;
if(copied) *copied = 2;
}else {
*dest = *src;
if(copied) *copied = 1;
}
return 0;
}
/*********************************************************************
* _mbccpy(MSVCRT.@)
*/
void CDECL _mbccpy(unsigned char* dest, const unsigned char* src)
{
_mbccpy_s_l(dest, 2, NULL, src, NULL);
}
/*********************************************************************
* _mbccpy_l(MSVCRT.@)
*/
void CDECL _mbccpy_l(unsigned char* dest, const unsigned char* src,
_locale_t locale)
{
_mbccpy_s_l(dest, 2, NULL, src, locale);
}
/*********************************************************************
* _mbccpy_s(MSVCRT.@)
*/
int CDECL _mbccpy_s(unsigned char* dest, size_t maxsize,
int *copied, const unsigned char* src)
{
return _mbccpy_s_l(dest, maxsize, copied, src, NULL);
}
/*********************************************************************
* _mbsncpy(MSVCRT.@)
* REMARKS
* The parameter n is the number or characters to copy, not the size of
* the buffer. Use _mbsnbcpy for a function analogical to strncpy
*/
unsigned char* CDECL _mbsncpy(unsigned char* dst, const unsigned char* src, size_t n)
{
unsigned char* ret = dst;
if(!n)
return dst;
if (get_mbcinfo()->ismbcodepage)
{
while (*src && n)
{
n--;
if (_ismbblead(*src))
{
if (!*(src+1))
{
*dst++ = 0;
*dst++ = 0;
break;
}
*dst++ = *src++;
}
*dst++ = *src++;
}
}
else
{
while (n)
{
n--;
if (!(*dst++ = *src++)) break;
}
}
while (n--) *dst++ = 0;
return ret;
}
/*********************************************************************
* _mbsnbcpy_s_l(MSVCRT.@)
* REMARKS
* Unlike _mbsnbcpy this function does not pad the rest of the dest
* string with 0
*/
int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
const unsigned char* src, size_t n, _locale_t locale)
{
size_t pos = 0;
if(!dst || size == 0)
return EINVAL;
if(!src)
{
dst[0] = '\0';
return EINVAL;
}
if(!n)
return 0;
if((locale ? locale->mbcinfo : get_mbcinfo())->ismbcodepage)
{
BOOL is_lead = FALSE;
while (*src && n)
{
if(pos == size)
{
dst[0] = '\0';
return ERANGE;
}
is_lead = (!is_lead && _ismbblead(*src));
n--;
dst[pos++] = *src++;
}
if (is_lead) /* if string ends with a lead, remove it */
dst[pos - 1] = 0;
}
else
{
while (n)
{
n--;
if(pos == size)
{
dst[0] = '\0';
return ERANGE;
}
if(!(*src)) break;
dst[pos++] = *src++;
}
}
if(pos < size)
dst[pos] = '\0';
else
{
dst[0] = '\0';
return ERANGE;
}
return 0;
}
/*********************************************************************
* _mbsnbcpy_s(MSVCRT.@)
*/
int CDECL _mbsnbcpy_s(unsigned char* dst, size_t size, const unsigned char* src, size_t n)
{
return _mbsnbcpy_s_l(dst, size, src, n, NULL);
}
/*********************************************************************
* _mbscpy_s_l(MSVCRT.@)
*/
int CDECL _mbscpy_s_l(unsigned char *dst, size_t size,
const unsigned char *src, _locale_t locale)
{
return _mbsnbcpy_s_l(dst, size, src, -1, locale);
}
/*********************************************************************
* _mbscpy_s(MSVCRT.@)
*/
int CDECL _mbscpy_s(unsigned char *dst, size_t size, const unsigned char *src)
{
return _mbscpy_s_l(dst, size, src, NULL);
}
/*********************************************************************
* _mbsnbcpy(MSVCRT.@)
* REMARKS
* Like strncpy this function doesn't enforce the string to be
* NUL-terminated
*/
unsigned char* CDECL _mbsnbcpy(unsigned char* dst, const unsigned char* src, size_t n)
{
unsigned char* ret = dst;
if(!n)
return dst;
if(get_mbcinfo()->ismbcodepage)
{
BOOL is_lead = FALSE;
while (*src && n)
{
is_lead = (!is_lead && _ismbblead(*src));
n--;
*dst++ = *src++;
}
if (is_lead) /* if string ends with a lead, remove it */
*(dst - 1) = 0;
}
else
{
while (n)
{
n--;
if (!(*dst++ = *src++)) break;
}
}
while (n--) *dst++ = 0;
return ret;
}
/*********************************************************************
* _mbscmp_l(MSVCRT.@)
*/
int CDECL _mbscmp_l(const unsigned char* str, const unsigned char* cmp, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if (!str || !cmp) return INT_MAX;
mbcinfo = locale ? locale->mbcinfo : get_mbcinfo();
if(mbcinfo->ismbcodepage)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbsnextc_l(str, locale);
cmpc = _mbsnextc_l(cmp, locale);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbscmp(MSVCRT.@)
*/
int CDECL _mbscmp(const unsigned char* str, const unsigned char* cmp)
{
return _mbscmp_l(str, cmp, NULL);
}
/*********************************************************************
* _mbsnbicoll_l(MSVCRT.@)
*/
int CDECL _mbsnbicoll_l(const unsigned char *str1, const unsigned char *str2, size_t len, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(!mbcinfo->ismbcodepage)
return _strnicoll_l((const char*)str1, (const char*)str2, len, locale);
return CompareStringA(mbcinfo->mblcid, NORM_IGNORECASE, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
}
/*********************************************************************
* _mbsicoll_l(MSVCRT.@)
*/
int CDECL _mbsicoll_l(const unsigned char *str1, const unsigned char *str2, _locale_t locale)
{
return _mbsnbicoll_l(str1, str2, -1, locale);
}
/*********************************************************************
* _mbsnbicoll(MSVCRT.@)
*/
int CDECL _mbsnbicoll(const unsigned char *str1, const unsigned char *str2, size_t len)
{
return _mbsnbicoll_l(str1, str2, len, NULL);
}
/*********************************************************************
* _mbsicoll(MSVCRT.@)
*/
int CDECL _mbsicoll(const unsigned char* str, const unsigned char* cmp)
{
#if _MSVCR_VER>=60 && _MSVCR_VER<=71
return CompareStringA(get_mbcinfo()->mblcid, NORM_IGNORECASE,
(const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
#else
return _mbsnbicoll_l(str, cmp, -1, NULL);
#endif
}
/*********************************************************************
* _mbsnbcoll_l(MSVCRT.@)
*/
int CDECL _mbsnbcoll_l(const unsigned char *str1, const unsigned char *str2, size_t len, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(!mbcinfo->ismbcodepage)
return _strncoll_l((const char*)str1, (const char*)str2, len, locale);
return CompareStringA(mbcinfo->mblcid, 0, (const char*)str1, len, (const char*)str2, len)-CSTR_EQUAL;
}
/*********************************************************************
* _mbscoll_l(MSVCRT.@)
*/
int CDECL _mbscoll_l(const unsigned char *str1, const unsigned char *str2, _locale_t locale)
{
return _mbsnbcoll_l(str1, str2, -1, locale);
}
/*********************************************************************
* _mbsnbcoll(MSVCRT.@)
*/
int CDECL _mbsnbcoll(const unsigned char *str1, const unsigned char *str2, size_t len)
{
return _mbsnbcoll_l(str1, str2, len, NULL);
}
/*********************************************************************
* _mbscoll(MSVCRT.@)
*/
int CDECL _mbscoll(const unsigned char* str, const unsigned char* cmp)
{
#if _MSVCR_VER>=60 && _MSVCR_VER<=71
return CompareStringA(get_mbcinfo()->mblcid, 0,
(const char*)str, -1, (const char*)cmp, -1)-CSTR_EQUAL;
#else
return _mbsnbcoll_l(str, cmp, -1, NULL);
#endif
}
/*********************************************************************
* _mbsicmp(MSVCRT.@)
*/
int CDECL _mbsicmp(const unsigned char* str, const unsigned char* cmp)
{
if(get_mbcinfo()->ismbcodepage)
{
unsigned int strc, cmpc;
do {
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbctolower(_mbsnextc(str));
cmpc = _mbctolower(_mbsnextc(cmp));
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* equal, use same increment */
} while(1);
}
return u_strcasecmp(str, cmp); /* ASCII CP */
}
/*********************************************************************
* _mbsncmp(MSVCRT.@)
*/
int CDECL _mbsncmp(const unsigned char* str, const unsigned char* cmp, size_t len)
{
if(!len)
return 0;
if(get_mbcinfo()->ismbcodepage)
{
unsigned int strc, cmpc;
while(len--)
{
int inc;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbsnextc(str);
cmpc = _mbsnextc(cmp);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
inc=(strc > 255) ? 2 : 1; /* Equal, use same increment */
str += inc;
cmp += inc;
}
return 0; /* Matched len chars */
}
return u_strncmp(str, cmp, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcmp(MSVCRT.@)
*/
int CDECL _mbsnbcmp(const unsigned char* str, const unsigned char* cmp, size_t len)
{
if (!len)
return 0;
if(get_mbcinfo()->ismbcodepage)
{
unsigned int strc, cmpc;
while (len)
{
int clen;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
if (_ismbblead(*str))
{
strc=(len>=2)?_mbsnextc(str):0;
clen=2;
}
else
{
strc=*str;
clen=1;
}
if (_ismbblead(*cmp))
cmpc=(len>=2)?_mbsnextc(cmp):0;
else
cmpc=*cmp;
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
len -= clen;
str += clen;
cmp += clen;
}
return 0; /* Matched len chars */
}
return u_strncmp(str,cmp,len);
}
/*********************************************************************
* _mbsnicmp(MSVCRT.@)
*
* Compare two multibyte strings case insensitively to 'len' characters.
*/
int CDECL _mbsnicmp(const unsigned char* str, const unsigned char* cmp, size_t len)
{
/* FIXME: No tolower() for mb strings yet */
if(get_mbcinfo()->ismbcodepage)
{
unsigned int strc, cmpc;
while(len--)
{
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
strc = _mbctolower(_mbsnextc(str));
cmpc = _mbctolower(_mbsnextc(cmp));
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
str +=(strc > 255) ? 2 : 1;
cmp +=(strc > 255) ? 2 : 1; /* Equal, use same increment */
}
return 0; /* Matched len chars */
}
return u_strncasecmp(str, cmp, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbicmp(MSVCRT.@)
*/
int CDECL _mbsnbicmp(const unsigned char* str, const unsigned char* cmp, size_t len)
{
if (!len)
return 0;
if(get_mbcinfo()->ismbcodepage)
{
unsigned int strc, cmpc;
while (len)
{
int clen;
if(!*str)
return *cmp ? -1 : 0;
if(!*cmp)
return 1;
if (_ismbblead(*str))
{
strc=(len>=2)?_mbsnextc(str):0;
clen=2;
}
else
{
strc=*str;
clen=1;
}
if (_ismbblead(*cmp))
cmpc=(len>=2)?_mbsnextc(cmp):0;
else
cmpc=*cmp;
strc = _mbctolower(strc);
cmpc = _mbctolower(cmpc);
if(strc != cmpc)
return strc < cmpc ? -1 : 1;
len -= clen;
str += clen;
cmp += clen;
}
return 0; /* Matched len bytes */
}
return u_strncasecmp(str,cmp,len);
}
/*********************************************************************
* _mbscat (MSVCRT.@)
*/
unsigned char * CDECL _mbscat( unsigned char *dst, const unsigned char *src )
{
strcat( (char *)dst, (const char *)src );
return dst;
}
/*********************************************************************
* _mbscat_s_l (MSVCRT.@)
*/
int CDECL _mbscat_s_l( unsigned char *dst, size_t size,
const unsigned char *src, _locale_t locale )
{
size_t i, j;
int ret = 0;
if(!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
for(i=0; i<size; i++)
if(!dst[i]) break;
if(i == size) {
MSVCRT_INVALID_PMT("dst is not NULL-terminated", EINVAL);
if(size) dst[0] = 0;
return EINVAL;
}
if(i && _ismbblead_l(dst[i-1], locale)) {
ret = EILSEQ;
i--;
}
for(j=0; src[j] && i+j<size; j++)
dst[i+j] = src[j];
if(i+j == size) {
MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
dst[0] = 0;
return ERANGE;
}
if(j && _ismbblead_l(src[j-1], locale)) {
ret = EILSEQ;
j--;
}
dst[i+j] = 0;
return ret;
}
/*********************************************************************
* _mbscat_s (MSVCRT.@)
*/
int CDECL _mbscat_s( unsigned char *dst, size_t size, const unsigned char *src )
{
return _mbscat_s_l(dst, size, src, NULL);
}
/*********************************************************************
* _mbscpy (MSVCRT.@)
*/
unsigned char* CDECL _mbscpy( unsigned char *dst, const unsigned char *src )
{
strcpy( (char *)dst, (const char *)src );
return dst;
}
/*********************************************************************
* _mbsstr (MSVCRT.@)
*/
unsigned char * CDECL _mbsstr(const unsigned char *haystack, const unsigned char *needle)
{
return (unsigned char *)strstr( (const char *)haystack, (const char *)needle );
}
/*********************************************************************
* _mbschr(MSVCRT.@)
*
* Find a multibyte character in a multibyte string.
*/
unsigned char* CDECL _mbschr(const unsigned char* s, unsigned int x)
{
if(get_mbcinfo()->ismbcodepage)
{
unsigned int c;
while (1)
{
c = _mbsnextc(s);
if (c == x)
return (unsigned char*)s;
if (!c)
return NULL;
s += c > 255 ? 2 : 1;
}
}
return u_strchr(s, x); /* ASCII CP */
}
/*********************************************************************
* _mbsrchr(MSVCRT.@)
*/
unsigned char* CDECL _mbsrchr(const unsigned char* s, unsigned int x)
{
if(get_mbcinfo()->ismbcodepage)
{
unsigned int c;
unsigned char* match=NULL;
if(!s)
return NULL;
while (1) {
c = _mbsnextc(s);
if (c == x)
match=(unsigned char*)s;
if (!c)
return match;
s +=(c > 255) ? 2 : 1;
}
}
return u_strrchr(s, x);
}
/*********************************************************************
* _mbstok_s_l(MSVCRT.@)
*/
unsigned char* CDECL _mbstok_s_l(unsigned char *str, const unsigned char *delim,
unsigned char **ctx, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
unsigned int c;
if(!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
if(!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
if(!MSVCRT_CHECK_PMT(str || *ctx)) return NULL;
if(locale)
mbcinfo = locale->mbcinfo;
else
mbcinfo = get_mbcinfo();
if(!mbcinfo->ismbcodepage)
return (unsigned char*)strtok_s((char*)str, (const char*)delim, (char**)ctx);
if(!str)
str = *ctx;
while((c=_mbsnextc(str)) && _mbschr(delim, c))
str += c>255 ? 2 : 1;
if(!*str)
{
*ctx = str;
return NULL;
}
*ctx = str + (c>255 ? 2 : 1);
while((c=_mbsnextc(*ctx)) && !_mbschr(delim, c))
*ctx += c>255 ? 2 : 1;
if (**ctx) {
*(*ctx)++ = 0;
if(c > 255)
*(*ctx)++ = 0;
}
return str;
}
/*********************************************************************
* _mbstok_s(MSVCRT.@)
*/
unsigned char* CDECL _mbstok_s(unsigned char *str,
const unsigned char *delim, unsigned char **ctx)
{
return _mbstok_s_l(str, delim, ctx, NULL);
}
/*********************************************************************
* _mbstok_l(MSVCRT.@)
*/
unsigned char* CDECL _mbstok_l(unsigned char *str,
const unsigned char *delim, _locale_t locale)
{
return _mbstok_s_l(str, delim, &msvcrt_get_thread_data()->mbstok_next, locale);
}
/*********************************************************************
* _mbstok(MSVCRT.@)
*/
unsigned char* CDECL _mbstok(unsigned char *str, const unsigned char *delim)
{
thread_data_t *data = msvcrt_get_thread_data();
#if _MSVCR_VER == 0
if(!str && !data->mbstok_next)
return NULL;
#endif
return _mbstok_s_l(str, delim, &data->mbstok_next, NULL);
}
/*********************************************************************
* _mbbtombc(MSVCRT.@)
*/
unsigned int CDECL _mbbtombc(unsigned int c)
{
if(get_mbcinfo()->mbcodepage == 932)
{
if(c >= 0x20 && c <= 0x7e) {
if((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0x30 && c <= 0x39))
return mbbtombc_932[c - 0x20] | 0x8200;
else
return mbbtombc_932[c - 0x20] | 0x8100;
}
else if(c >= 0xa1 && c <= 0xdf) {
if(c >= 0xa6 && c <= 0xdd && c != 0xb0)
return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8300;
else
return mbbtombc_932[c - 0xa1 + 0x5f] | 0x8100;
}
}
return c; /* not Japanese or no MB char */
}
/*********************************************************************
* _ismbbkana_l(MSVCRT.@)
*/
int CDECL _ismbbkana_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(locale)
mbcinfo = locale->mbcinfo;
else
mbcinfo = get_mbcinfo();
if(mbcinfo->mbcodepage == 932)
{
/* Japanese/Katakana, CP 932 */
return (c >= 0xa1 && c <= 0xdf);
}
return 0;
}
/*********************************************************************
* _ismbbkana(MSVCRT.@)
*/
int CDECL _ismbbkana(unsigned int c)
{
return _ismbbkana_l( c, NULL );
}
/*********************************************************************
* _ismbcdigit_l(MSVCRT.@)
*/
int CDECL _ismbcdigit_l(unsigned int ch, _locale_t locale)
{
return _iswdigit_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcdigit(MSVCRT.@)
*/
int CDECL _ismbcdigit(unsigned int ch)
{
return _ismbcdigit_l( ch, NULL );
}
/*********************************************************************
* _ismbcgraph_l(MSVCRT.@)
*/
int CDECL _ismbcgraph_l(unsigned int ch, _locale_t locale)
{
return _iswgraph_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcgraph(MSVCRT.@)
*/
int CDECL _ismbcgraph(unsigned int ch)
{
return _ismbcgraph_l( ch, NULL );
}
/*********************************************************************
* _ismbcalpha_l (MSVCRT.@)
*/
int CDECL _ismbcalpha_l(unsigned int ch, _locale_t locale)
{
return _iswalpha_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcalpha (MSVCRT.@)
*/
int CDECL _ismbcalpha(unsigned int ch)
{
return _ismbcalpha_l( ch, NULL );
}
/*********************************************************************
* _ismbclower_l (MSVCRT.@)
*/
int CDECL _ismbclower_l(unsigned int ch, _locale_t locale)
{
return _iswlower_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbclower (MSVCRT.@)
*/
int CDECL _ismbclower(unsigned int ch)
{
return _ismbclower_l( ch, NULL );
}
/*********************************************************************
* _ismbcupper_l (MSVCRT.@)
*/
int CDECL _ismbcupper_l(unsigned int ch, _locale_t locale)
{
return _iswupper_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcupper (MSVCRT.@)
*/
int CDECL _ismbcupper(unsigned int ch)
{
return _ismbcupper_l( ch, NULL );
}
/*********************************************************************
* _ismbcsymbol(MSVCRT.@)
*/
int CDECL _ismbcsymbol(unsigned int ch)
{
wchar_t wch = msvcrt_mbc_to_wc( ch );
WORD ctype;
if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
{
WARN("GetStringTypeW failed on %x\n", ch);
return 0;
}
return ((ctype & C3_SYMBOL) != 0);
}
/*********************************************************************
* _ismbcalnum_l (MSVCRT.@)
*/
int CDECL _ismbcalnum_l(unsigned int ch, _locale_t locale)
{
return _iswalnum_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcalnum (MSVCRT.@)
*/
int CDECL _ismbcalnum(unsigned int ch)
{
return _ismbcalnum_l( ch, NULL );
}
/*********************************************************************
* _ismbcspace_l (MSVCRT.@)
*/
int CDECL _ismbcspace_l(unsigned int ch, _locale_t locale)
{
return _iswspace_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcspace (MSVCRT.@)
*/
int CDECL _ismbcspace(unsigned int ch)
{
return _ismbcspace_l( ch, NULL );
}
/*********************************************************************
* _ismbcprint_l (MSVCRT.@)
*/
int CDECL _ismbcprint_l(unsigned int ch, _locale_t locale)
{
return _iswprint_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcprint (MSVCRT.@)
*/
int CDECL _ismbcprint(unsigned int ch)
{
return _ismbcprint_l( ch, NULL );
}
/*********************************************************************
* _ismbcpunct_l (MSVCRT.@)
*/
int CDECL _ismbcpunct_l(unsigned int ch, _locale_t locale)
{
return _iswpunct_l( msvcrt_mbc_to_wc_l(ch, locale), locale );
}
/*********************************************************************
* _ismbcpunct(MSVCRT.@)
*/
int CDECL _ismbcpunct(unsigned int ch)
{
return _ismbcpunct_l( ch, NULL );
}
/*********************************************************************
* _ismbchira(MSVCRT.@)
*/
int CDECL _ismbchira(unsigned int c)
{
if(get_mbcinfo()->mbcodepage == 932)
{
/* Japanese/Hiragana, CP 932 */
return (c >= 0x829f && c <= 0x82f1);
}
return 0;
}
/*********************************************************************
* _ismbckata(MSVCRT.@)
*/
int CDECL _ismbckata(unsigned int c)
{
if(get_mbcinfo()->mbcodepage == 932)
{
/* Japanese/Katakana, CP 932 */
return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
}
return 0;
}
/*********************************************************************
* _ismbblead_l(MSVCRT.@)
*/
int CDECL _ismbblead_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
return (mbcinfo->mbctype[(c&0xff) + 1] & _M1) != 0;
}
/*********************************************************************
* _ismbblead(MSVCRT.@)
*/
int CDECL _ismbblead(unsigned int c)
{
return _ismbblead_l(c, NULL);
}
/*********************************************************************
* _ismbbtrail_l(MSVCRT.@)
*/
int CDECL _ismbbtrail_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
return (mbcinfo->mbctype[(c&0xff) + 1] & _M2) != 0;
}
/*********************************************************************
* _ismbbtrail(MSVCRT.@)
*/
int CDECL _ismbbtrail(unsigned int c)
{
return _ismbbtrail_l(c, NULL);
}
/*********************************************************************
* _ismbclegal_l(MSVCRT.@)
*/
int CDECL _ismbclegal_l(unsigned int c, _locale_t locale)
{
return _ismbblead_l(HIBYTE(c), locale) && _ismbbtrail_l(LOBYTE(c), locale);
}
/*********************************************************************
* _ismbclegal(MSVCRT.@)
*/
int CDECL _ismbclegal(unsigned int c)
{
return _ismbclegal_l(c, NULL);
}
/*********************************************************************
* _ismbslead(MSVCRT.@)
*/
int CDECL _ismbslead(const unsigned char* start, const unsigned char* str)
{
int lead = 0;
if(!get_mbcinfo()->ismbcodepage)
return 0;
/* Lead bytes can also be trail bytes so we need to analyse the string
*/
while (start <= str)
{
if (!*start)
return 0;
lead = !lead && _ismbblead(*start);
start++;
}
return lead ? -1 : 0;
}
/*********************************************************************
* _ismbstrail(MSVCRT.@)
*/
int CDECL _ismbstrail(const unsigned char* start, const unsigned char* str)
{
/* Note: this function doesn't check _ismbbtrail */
if ((str > start) && _ismbslead(start, str-1))
return -1;
else
return 0;
}
/*********************************************************************
* _mbbtype_l(MSVCRT.@)
*/
int CDECL _mbbtype_l(unsigned char c, int type, _locale_t locale)
{
if (type == 1)
return _ismbbtrail_l(c, locale) ? _MBC_TRAIL : _MBC_ILLEGAL;
else
return _ismbblead_l(c, locale) ? _MBC_LEAD
: _isprint_l(c, locale) ? _MBC_SINGLE : _MBC_ILLEGAL;
}
/*********************************************************************
* _mbbtype(MSVCRT.@)
*/
int CDECL _mbbtype(unsigned char c, int type)
{
return _mbbtype_l(c, type, NULL);
}
/*********************************************************************
* _mbsbtype (MSVCRT.@)
*/
int CDECL _mbsbtype(const unsigned char *str, size_t count)
{
int lead = 0;
const unsigned char *end = str + count;
/* Lead bytes can also be trail bytes so we need to analyse the string.
* Also we must return _MBC_ILLEGAL for chars past the end of the string
*/
while (str < end) /* Note: we skip the last byte - will check after the loop */
{
if (!*str)
return _MBC_ILLEGAL;
lead = get_mbcinfo()->ismbcodepage && !lead && _ismbblead(*str);
str++;
}
if (lead)
if (_ismbbtrail(*str))
return _MBC_TRAIL;
else
return _MBC_ILLEGAL;
else
if (_ismbblead(*str))
return _MBC_LEAD;
else
return _MBC_SINGLE;
}
/*********************************************************************
* _mbsset(MSVCRT.@)
*/
unsigned char* CDECL _mbsset(unsigned char* str, unsigned int c)
{
unsigned char* ret = str;
if(!get_mbcinfo()->ismbcodepage || c < 256)
return u__strset(str, c); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1])
{
*str++ = c >> 8;
*str++ = c & 0xff;
}
if(str[0])
str[0] = '\0'; /* FIXME: OK to shorten? */
return ret;
}
/*********************************************************************
* _mbsnbset(MSVCRT.@)
*/
unsigned char* CDECL _mbsnbset(unsigned char *str, unsigned int c, size_t len)
{
unsigned char *ret = str;
if(!len)
return ret;
if(!get_mbcinfo()->ismbcodepage || c < 256)
return u__strnset(str, c, len); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1] && (len > 1))
{
*str++ = c >> 8;
len--;
*str++ = c & 0xff;
len--;
}
if(len && str[0]) {
/* as per msdn pad with a blank character */
str[0] = ' ';
}
return ret;
}
/*********************************************************************
* _mbsnset(MSVCRT.@)
*/
unsigned char* CDECL _mbsnset(unsigned char* str, unsigned int c, size_t len)
{
unsigned char *ret = str;
if(!len)
return ret;
if(!get_mbcinfo()->ismbcodepage || c < 256)
return u__strnset(str, c, len); /* ASCII CP or SB char */
c &= 0xffff; /* Strip high bits */
while(str[0] && str[1] && len--)
{
*str++ = c >> 8;
*str++ = c & 0xff;
}
if(len && str[0])
str[0] = '\0'; /* FIXME: OK to shorten? */
return ret;
}
/*********************************************************************
* _mbsnccnt(MSVCRT.@)
* 'c' is for 'character'.
*/
size_t CDECL _mbsnccnt(const unsigned char* str, size_t len)
{
size_t ret;
if(get_mbcinfo()->ismbcodepage)
{
ret=0;
while(*str && len-- > 0)
{
if(_ismbblead(*str))
{
if (!len)
break;
len--;
str++;
}
str++;
ret++;
}
return ret;
}
ret=u_strlen(str);
return min(ret, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcnt(MSVCRT.@)
* 'b' is for byte count.
*/
size_t CDECL _mbsnbcnt(const unsigned char* str, size_t len)
{
size_t ret;
if(get_mbcinfo()->ismbcodepage)
{
const unsigned char* xstr = str;
while(*xstr && len-- > 0)
{
if (_ismbblead(*xstr++))
xstr++;
}
return xstr-str;
}
ret=u_strlen(str);
return min(ret, len); /* ASCII CP */
}
/*********************************************************************
* _mbsnbcat(MSVCRT.@)
*/
unsigned char* CDECL _mbsnbcat(unsigned char* dst, const unsigned char* src, size_t len)
{
if(get_mbcinfo()->ismbcodepage)
{
unsigned char *res = dst;
while (*dst) {
if (_ismbblead(*dst++)) {
if (*dst) {
dst++;
} else {
/* as per msdn overwrite the lead byte in front of '\0' */
dst--;
break;
}
}
}
while (*src && len--) *dst++ = *src++;
*dst = '\0';
return res;
}
return u_strncat(dst, src, len); /* ASCII CP */
}
int CDECL _mbsnbcat_s(unsigned char *dst, size_t size, const unsigned char *src, size_t len)
{
unsigned char *ptr = dst;
size_t i;
if (!dst && !size && !src && !len)
return 0;
if (!dst || !size || !src)
{
if (dst && size)
*dst = '\0';
*_errno() = EINVAL;
return EINVAL;
}
/* Find the null terminator of the destination buffer. */
while (size && *ptr)
size--, ptr++;
if (!size)
{
*dst = '\0';
*_errno() = EINVAL;
return EINVAL;
}
/* If necessary, check that the character preceding the null terminator is
* a lead byte and move the pointer back by one for later overwrite. */
if (ptr != dst && get_mbcinfo()->ismbcodepage && _ismbblead(*(ptr - 1)))
size++, ptr--;
for (i = 0; *src && i < len; i++)
{
*ptr++ = *src++;
size--;
if (!size)
{
*dst = '\0';
*_errno() = ERANGE;
return ERANGE;
}
}
*ptr = '\0';
return 0;
}
/*********************************************************************
* _mbsncat(MSVCRT.@)
*/
unsigned char* CDECL _mbsncat(unsigned char* dst, const unsigned char* src, size_t len)
{
if(get_mbcinfo()->ismbcodepage)
{
unsigned char *res = dst;
while (*dst)
{
if (_ismbblead(*dst++))
dst++;
}
while (*src && len--)
{
*dst++ = *src;
if(_ismbblead(*src++))
*dst++ = *src++;
}
*dst = '\0';
return res;
}
return u_strncat(dst, src, len); /* ASCII CP */
}
/*********************************************************************
* _mbslwr(MSVCRT.@)
*/
unsigned char* CDECL _mbslwr(unsigned char* s)
{
unsigned char *ret = s;
if (!s)
return NULL;
if (get_mbcinfo()->ismbcodepage)
{
unsigned int c;
while (*s)
{
c = _mbctolower(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s; s++) *s = _tolower_l(*s, NULL);
return ret;
}
/*********************************************************************
* _mbslwr_s(MSVCRT.@)
*/
int CDECL _mbslwr_s(unsigned char* s, size_t len)
{
if (!s && !len)
{
return 0;
}
else if (!s || !len)
{
*_errno() = EINVAL;
return EINVAL;
}
if (get_mbcinfo()->ismbcodepage)
{
unsigned int c;
for ( ; *s && len > 0; len--)
{
c = _mbctolower(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s && len > 0; s++, len--) *s = _tolower_l(*s, NULL);
if (*s)
{
*s = '\0';
*_errno() = EINVAL;
return EINVAL;
}
return 0;
}
/*********************************************************************
* _mbsupr(MSVCRT.@)
*/
unsigned char* CDECL _mbsupr(unsigned char* s)
{
unsigned char *ret = s;
if (!s)
return NULL;
if (get_mbcinfo()->ismbcodepage)
{
unsigned int c;
while (*s)
{
c = _mbctoupper(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s; s++) *s = _toupper_l(*s, NULL);
return ret;
}
/*********************************************************************
* _mbsupr_s(MSVCRT.@)
*/
int CDECL _mbsupr_s(unsigned char* s, size_t len)
{
if (!s && !len)
{
return 0;
}
else if (!s || !len)
{
*_errno() = EINVAL;
return EINVAL;
}
if (get_mbcinfo()->ismbcodepage)
{
unsigned int c;
for ( ; *s && len > 0; len--)
{
c = _mbctoupper(_mbsnextc(s));
/* Note that I assume that the size of the character is unchanged */
if (c > 255)
{
*s++=(c>>8);
c=c & 0xff;
}
*s++=c;
}
}
else for ( ; *s && len > 0; s++, len--) *s = _toupper_l(*s, NULL);
if (*s)
{
*s = '\0';
*_errno() = EINVAL;
return EINVAL;
}
return 0;
}
/*********************************************************************
* _mbsspn_l (MSVCRT.@)
*/
size_t CDECL _mbsspn_l(const unsigned char* string,
const unsigned char* set, _locale_t locale)
{
const unsigned char *p, *q;
for (p = string; *p; p++)
{
for (q = set; *q; q++)
{
if (_ismbblead_l(*q, locale))
{
/* duplicate a bug in native implementation */
if (!q[1]) break;
if (p[0] == q[0] && p[1] == q[1])
{
p++;
break;
}
q++;
}
else
{
if (p[0] == q[0]) break;
}
}
if (!*q) break;
}
return p - string;
}
/*********************************************************************
* _mbsspn (MSVCRT.@)
*/
size_t CDECL _mbsspn(const unsigned char* string, const unsigned char* set)
{
return _mbsspn_l(string, set, NULL);
}
/*********************************************************************
* _mbsspnp (MSVCRT.@)
*/
unsigned char* CDECL _mbsspnp(const unsigned char* string, const unsigned char* set)
{
string += _mbsspn( string, set );
return *string ? (unsigned char*)string : NULL;
}
/*********************************************************************
* _mbscspn_l (MSVCRT.@)
*/
size_t CDECL _mbscspn_l(const unsigned char* str,
const unsigned char* cmp, _locale_t locale)
{
const unsigned char *p, *q;
for (p = str; *p; p++)
{
for (q = cmp; *q; q++)
{
if (_ismbblead_l(*q, locale))
{
/* duplicate a bug in native implementation */
if (!q[1]) return 0;
if (p[0] == q[0] && p[1] == q[1])
return p - str;
q++;
}
else if (p[0] == q[0])
return p - str;
}
}
return p - str;
}
/*********************************************************************
* _mbscspn (MSVCRT.@)
*/
size_t CDECL _mbscspn(const unsigned char* str, const unsigned char* cmp)
{
return _mbscspn_l(str, cmp, NULL);
}
/*********************************************************************
* _mbsrev (MSVCRT.@)
*/
unsigned char* CDECL _mbsrev(unsigned char* str)
{
int i, len = _mbslen(str);
unsigned char *p, *temp=malloc(len*2);
if(!temp)
return str;
/* unpack multibyte string to temp buffer */
p=str;
for(i=0; i<len; i++)
{
if (_ismbblead(*p))
{
temp[i*2]=*p++;
temp[i*2+1]=*p++;
}
else
{
temp[i*2]=*p++;
temp[i*2+1]=0;
}
}
/* repack it in the reverse order */
p=str;
for(i=len-1; i>=0; i--)
{
if(_ismbblead(temp[i*2]))
{
*p++=temp[i*2];
*p++=temp[i*2+1];
}
else
{
*p++=temp[i*2];
}
}
free(temp);
return str;
}
/*********************************************************************
* _mbspbrk (MSVCRT.@)
*/
unsigned char* CDECL _mbspbrk(const unsigned char* str, const unsigned char* accept)
{
const unsigned char* p;
while(*str)
{
for(p = accept; *p; p += (_ismbblead(*p)?2:1) )
{
if (*p == *str)
if( !_ismbblead(*p) || ( *(p+1) == *(str+1) ) )
return (unsigned char*)str;
}
str += (_ismbblead(*str)?2:1);
}
return NULL;
}
/*
* Functions depending on locale codepage
*/
/*********************************************************************
* mblen(MSVCRT.@)
* REMARKS
* Unlike most of the multibyte string functions this function uses
* the locale codepage, not the codepage set by _setmbcp
*/
int CDECL mblen(const char* str, size_t size)
{
if (str && *str && size)
{
if(get_locinfo()->mb_cur_max == 1)
return 1; /* ASCII CP */
return !isleadbyte((unsigned char)*str) ? 1 : (size>1 ? 2 : -1);
}
return 0;
}
/*********************************************************************
* mbrlen(MSVCRT.@)
*/
size_t CDECL mbrlen(const char *str, size_t len, mbstate_t *state)
{
mbstate_t s = (state ? *state : 0);
size_t ret;
if(!len || !str || !*str)
return 0;
if(get_locinfo()->mb_cur_max == 1) {
return 1;
}else if(!s && isleadbyte((unsigned char)*str)) {
if(len == 1) {
s = (unsigned char)*str;
ret = -2;
}else {
ret = 2;
}
}else if(!s) {
ret = 1;
}else {
s = 0;
ret = 2;
}
if(state)
*state = s;
return ret;
}
/*********************************************************************
* _mbstrlen_l(MSVCRT.@)
*/
size_t CDECL _mbstrlen_l(const char* str, _locale_t locale)
{
pthreadlocinfo locinfo;
if(!locale)
locinfo = get_locinfo();
else
locinfo = locale->locinfo;
if(locinfo->mb_cur_max > 1) {
size_t len;
len = MultiByteToWideChar(locinfo->lc_codepage, MB_ERR_INVALID_CHARS,
str, -1, NULL, 0);
if (!len) {
*_errno() = EILSEQ;
return -1;
}
return len - 1;
}
return strlen(str);
}
/*********************************************************************
* _mbstrlen(MSVCRT.@)
*/
size_t CDECL _mbstrlen(const char* str)
{
return _mbstrlen_l(str, NULL);
}
/*********************************************************************
* _mbtowc_l(MSVCRT.@)
*/
int CDECL _mbtowc_l(wchar_t *dst, const char* str, size_t n, _locale_t locale)
{
pthreadlocinfo locinfo;
wchar_t tmpdst;
if(!locale)
locinfo = get_locinfo();
else
locinfo = locale->locinfo;
if(n <= 0 || !str)
return 0;
if(!*str) {
if(dst) *dst = 0;
return 0;
}
if(!locinfo->lc_codepage) {
if(dst) *dst = (unsigned char)*str;
return 1;
}
if(n>=2 && _isleadbyte_l((unsigned char)*str, locale)) {
if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 2, &tmpdst, 1))
return -1;
if(dst) *dst = tmpdst;
return 2;
}
if(!MultiByteToWideChar(locinfo->lc_codepage, 0, str, 1, &tmpdst, 1))
return -1;
if(dst) *dst = tmpdst;
return 1;
}
/*********************************************************************
* mbtowc(MSVCRT.@)
*/
int CDECL mbtowc(wchar_t *dst, const char* str, size_t n)
{
return _mbtowc_l(dst, str, n, NULL);
}
/*********************************************************************
* btowc(MSVCRT.@)
*/
wint_t CDECL btowc(int c)
{
unsigned char letter = c;
wchar_t ret;
if(c == EOF)
return WEOF;
if(!get_locinfo()->lc_codepage)
return c & 255;
if(!MultiByteToWideChar(get_locinfo()->lc_codepage,
MB_ERR_INVALID_CHARS, (LPCSTR)&letter, 1, &ret, 1))
return WEOF;
return ret;
}
/*********************************************************************
* mbrtowc(MSVCRT.@)
*/
size_t CDECL mbrtowc(wchar_t *dst, const char *str,
size_t n, mbstate_t *state)
{
pthreadlocinfo locinfo = get_locinfo();
mbstate_t s = (state ? *state : 0);
char tmpstr[2];
int len = 0;
if(dst)
*dst = 0;
if(!n || !str || !*str)
return 0;
if(locinfo->mb_cur_max == 1) {
tmpstr[len++] = *str;
}else if(!s && isleadbyte((unsigned char)*str)) {
if(n == 1) {
s = (unsigned char)*str;
len = -2;
}else {
tmpstr[0] = str[0];
tmpstr[1] = str[1];
len = 2;
}
}else if(!s) {
tmpstr[len++] = *str;
}else {
tmpstr[0] = s;
tmpstr[1] = *str;
len = 2;
s = 0;
}
if(len > 0) {
if(!MultiByteToWideChar(locinfo->lc_codepage, 0, tmpstr, len, dst, dst ? 1 : 0))
len = -1;
}
if(state)
*state = s;
return len;
}
/*********************************************************************
* _mbstowcs_l(MSVCRT.@)
*/
size_t CDECL _mbstowcs_l(wchar_t *wcstr, const char *mbstr,
size_t count, _locale_t locale)
{
pthreadlocinfo locinfo;
size_t i, size;
if(!mbstr) {
*_errno() = EINVAL;
return -1;
}
if(!locale)
locinfo = get_locinfo();
else
locinfo = locale->locinfo;
if(!locinfo->lc_codepage) {
if(!wcstr)
return strlen(mbstr);
for(i=0; i<count; i++) {
wcstr[i] = (unsigned char)mbstr[i];
if(!wcstr[i]) break;
}
return i;
}
/* Ignore count parameter */
if(!wcstr) {
size = MultiByteToWideChar(locinfo->lc_codepage,
MB_ERR_INVALID_CHARS, mbstr, -1, NULL, 0);
if(!size) {
*_errno() = EILSEQ;
return -1;
}
return size - 1;
}
for(i=0, size=0; i<count; i++) {
if(mbstr[size] == '\0')
break;
size += (_isleadbyte_l((unsigned char)mbstr[size], locale) ? 2 : 1);
}
if(size) {
size = MultiByteToWideChar(locinfo->lc_codepage,
MB_ERR_INVALID_CHARS, mbstr, size, wcstr, count);
if(!size) {
if(count) wcstr[0] = '\0';
*_errno() = EILSEQ;
return -1;
}
}
if(size<count)
wcstr[size] = '\0';
return size;
}
/*********************************************************************
* mbstowcs(MSVCRT.@)
*/
size_t CDECL mbstowcs(wchar_t *wcstr,
const char *mbstr, size_t count)
{
return _mbstowcs_l(wcstr, mbstr, count, NULL);
}
/*********************************************************************
* _mbstowcs_s_l(MSVCRT.@)
*/
int CDECL _mbstowcs_s_l(size_t *ret, wchar_t *wcstr,
size_t size, const char *mbstr, size_t count, _locale_t locale)
{
size_t conv;
int err = 0;
if(!wcstr && !size) {
conv = _mbstowcs_l(NULL, mbstr, 0, locale);
if(ret)
*ret = conv+1;
return 0;
}
if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mbstr != NULL)) {
if(size) wcstr[0] = '\0';
return EINVAL;
}
if(count==_TRUNCATE || size<count)
conv = size;
else
conv = count;
conv = _mbstowcs_l(wcstr, mbstr, conv, locale);
if(conv<size)
wcstr[conv++] = '\0';
else if(conv==size && count==_TRUNCATE && wcstr[conv-1]!='\0') {
wcstr[conv-1] = '\0';
err = STRUNCATE;
}else if(conv==size && wcstr[conv-1]!='\0') {
MSVCRT_INVALID_PMT("wcstr[size] is too small", ERANGE);
if(size)
wcstr[0] = '\0';
return ERANGE;
}
if(ret)
*ret = conv;
return err;
}
/*********************************************************************
* mbstowcs_s(MSVCRT.@)
*/
int CDECL _mbstowcs_s(size_t *ret, wchar_t *wcstr,
size_t size, const char *mbstr, size_t count)
{
return _mbstowcs_s_l(ret, wcstr, size, mbstr, count, NULL);
}
/*********************************************************************
* mbsrtowcs(MSVCRT.@)
*/
size_t CDECL mbsrtowcs(wchar_t *wcstr,
const char **pmbstr, size_t count, mbstate_t *state)
{
mbstate_t s = (state ? *state : 0);
wchar_t tmpdst;
size_t ret = 0;
const char *p;
if(!MSVCRT_CHECK_PMT(pmbstr != NULL))
return -1;
p = *pmbstr;
while(!wcstr || count>ret) {
int ch_len = mbrtowc(&tmpdst, p, 2, &s);
if(wcstr)
wcstr[ret] = tmpdst;
if(ch_len < 0) {
return -1;
}else if(ch_len == 0) {
if(wcstr) *pmbstr = NULL;
return ret;
}
p += ch_len;
ret++;
}
if(wcstr) *pmbstr = p;
return ret;
}
/*********************************************************************
* mbsrtowcs_s(MSVCRT.@)
*/
int CDECL mbsrtowcs_s(size_t *ret, wchar_t *wcstr, size_t len,
const char **mbstr, size_t count, mbstate_t *state)
{
size_t tmp;
if(!ret) ret = &tmp;
if(!MSVCRT_CHECK_PMT(!!wcstr == !!len)) {
*ret = -1;
return EINVAL;
}
*ret = mbsrtowcs(wcstr, mbstr, count>len ? len : count, state);
if(*ret == -1) {
if(wcstr) *wcstr = 0;
return *_errno();
}
(*ret)++;
if(*ret > len) {
/* no place for terminating '\0' */
if(wcstr) *wcstr = 0;
return 0;
}
if(wcstr) wcstr[(*ret)-1] = 0;
return 0;
}
/*********************************************************************
* _mbctohira (MSVCRT.@)
*
* Converts a sjis katakana character to hiragana.
*/
unsigned int CDECL _mbctohira(unsigned int c)
{
if(_ismbckata(c) && c <= 0x8393)
return (c - 0x8340 - (c >= 0x837f ? 1 : 0)) + 0x829f;
return c;
}
/*********************************************************************
* _mbctokata (MSVCRT.@)
*
* Converts a sjis hiragana character to katakana.
*/
unsigned int CDECL _mbctokata(unsigned int c)
{
if(_ismbchira(c))
return (c - 0x829f) + 0x8340 + (c >= 0x82de ? 1 : 0);
return c;
}
/*********************************************************************
* _ismbcl0_l (MSVCRT.@)
*/
int CDECL _ismbcl0_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(mbcinfo->mbcodepage == 932)
{
/* JIS non-Kanji */
return _ismbclegal_l(c, locale) && c >= 0x8140 && c <= 0x889e;
}
return 0;
}
/*********************************************************************
* _ismbcl0 (MSVCRT.@)
*/
int CDECL _ismbcl0(unsigned int c)
{
return _ismbcl0_l(c, NULL);
}
/*********************************************************************
* _ismbcl1_l (MSVCRT.@)
*/
int CDECL _ismbcl1_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(mbcinfo->mbcodepage == 932)
{
/* JIS level-1 */
return _ismbclegal_l(c, locale) && c >= 0x889f && c <= 0x9872;
}
return 0;
}
/*********************************************************************
* _ismbcl1 (MSVCRT.@)
*/
int CDECL _ismbcl1(unsigned int c)
{
return _ismbcl1_l(c, NULL);
}
/*********************************************************************
* _ismbcl2_l (MSVCRT.@)
*/
int CDECL _ismbcl2_l(unsigned int c, _locale_t locale)
{
pthreadmbcinfo mbcinfo;
if(!locale)
mbcinfo = get_mbcinfo();
else
mbcinfo = locale->mbcinfo;
if(mbcinfo->mbcodepage == 932)
{
/* JIS level-2 */
return _ismbclegal_l(c, locale) && c >= 0x989f && c <= 0xeaa4;
}
return 0;
}
/*********************************************************************
* _ismbcl2 (MSVCRT.@)
*/
int CDECL _ismbcl2(unsigned int c)
{
return _ismbcl2_l(c, NULL);
}
|
636008.c | /*
* net/sched/sch_prio.c Simple 3-band priority "scheduler".
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* Authors: Alexey Kuznetsov, <[email protected]>
* Fixes: 19990609: J Hadi Salim <[email protected]>:
* Init -- EINVAL when opt undefined
*/
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <net/netlink.h>
#include <net/pkt_sched.h>
struct prio_sched_data {
int bands;
struct tcf_proto *filter_list;
u8 prio2band[TC_PRIO_MAX+1];
struct Qdisc *queues[TCQ_PRIO_BANDS];
};
static struct Qdisc *
prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
{
struct prio_sched_data *q = qdisc_priv(sch);
u32 band = skb->priority;
struct tcf_result res;
int err;
*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
if (TC_H_MAJ(skb->priority) != sch->handle) {
err = tc_classify(skb, q->filter_list, &res);
#ifdef CONFIG_NET_CLS_ACT
switch (err) {
case TC_ACT_STOLEN:
case TC_ACT_QUEUED:
*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
case TC_ACT_SHOT:
return NULL;
}
#endif
if (!q->filter_list || err < 0) {
if (TC_H_MAJ(band))
band = 0;
return q->queues[q->prio2band[band & TC_PRIO_MAX]];
}
band = res.classid;
}
band = TC_H_MIN(band) - 1;
if (band >= q->bands)
return q->queues[q->prio2band[0]];
return q->queues[band];
}
static int
prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
struct Qdisc *qdisc;
int ret;
qdisc = prio_classify(skb, sch, &ret);
#ifdef CONFIG_NET_CLS_ACT
if (qdisc == NULL) {
if (ret & __NET_XMIT_BYPASS)
sch->qstats.drops++;
kfree_skb(skb);
return ret;
}
#endif
ret = qdisc_enqueue(skb, qdisc);
if (ret == NET_XMIT_SUCCESS) {
sch->q.qlen++;
return NET_XMIT_SUCCESS;
}
if (net_xmit_drop_count(ret))
sch->qstats.drops++;
return ret;
}
static struct sk_buff *prio_peek(struct Qdisc *sch)
{
struct prio_sched_data *q = qdisc_priv(sch);
int prio;
for (prio = 0; prio < q->bands; prio++) {
struct Qdisc *qdisc = q->queues[prio];
struct sk_buff *skb = qdisc->ops->peek(qdisc);
if (skb)
return skb;
}
return NULL;
}
static struct sk_buff *prio_dequeue(struct Qdisc *sch)
{
struct prio_sched_data *q = qdisc_priv(sch);
int prio;
for (prio = 0; prio < q->bands; prio++) {
struct Qdisc *qdisc = q->queues[prio];
struct sk_buff *skb = qdisc_dequeue_peeked(qdisc);
if (skb) {
qdisc_bstats_update(sch, skb);
sch->q.qlen--;
return skb;
}
}
return NULL;
}
static unsigned int prio_drop(struct Qdisc *sch)
{
struct prio_sched_data *q = qdisc_priv(sch);
int prio;
unsigned int len;
struct Qdisc *qdisc;
for (prio = q->bands-1; prio >= 0; prio--) {
qdisc = q->queues[prio];
if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {
sch->q.qlen--;
return len;
}
}
return 0;
}
static void
prio_reset(struct Qdisc *sch)
{
int prio;
struct prio_sched_data *q = qdisc_priv(sch);
for (prio = 0; prio < q->bands; prio++)
qdisc_reset(q->queues[prio]);
sch->q.qlen = 0;
}
static void
prio_destroy(struct Qdisc *sch)
{
int prio;
struct prio_sched_data *q = qdisc_priv(sch);
tcf_destroy_chain(&q->filter_list);
for (prio = 0; prio < q->bands; prio++)
qdisc_destroy(q->queues[prio]);
}
static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
{
struct prio_sched_data *q = qdisc_priv(sch);
struct tc_prio_qopt *qopt;
int i;
if (nla_len(opt) < sizeof(*qopt))
return -EINVAL;
qopt = nla_data(opt);
if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
return -EINVAL;
for (i = 0; i <= TC_PRIO_MAX; i++) {
if (qopt->priomap[i] >= qopt->bands)
return -EINVAL;
}
sch_tree_lock(sch);
q->bands = qopt->bands;
memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
for (i = q->bands; i < TCQ_PRIO_BANDS; i++) {
struct Qdisc *child = q->queues[i];
q->queues[i] = &noop_qdisc;
if (child != &noop_qdisc) {
qdisc_tree_decrease_qlen(child, child->q.qlen);
qdisc_destroy(child);
}
}
sch_tree_unlock(sch);
for (i = 0; i < q->bands; i++) {
if (q->queues[i] == &noop_qdisc) {
struct Qdisc *child, *old;
child = qdisc_create_dflt(sch->dev_queue,
&pfifo_qdisc_ops,
TC_H_MAKE(sch->handle, i + 1));
if (child) {
sch_tree_lock(sch);
old = q->queues[i];
q->queues[i] = child;
if (old != &noop_qdisc) {
qdisc_tree_decrease_qlen(old,
old->q.qlen);
qdisc_destroy(old);
}
sch_tree_unlock(sch);
}
}
}
return 0;
}
static int prio_init(struct Qdisc *sch, struct nlattr *opt)
{
struct prio_sched_data *q = qdisc_priv(sch);
int i;
for (i = 0; i < TCQ_PRIO_BANDS; i++)
q->queues[i] = &noop_qdisc;
if (opt == NULL) {
return -EINVAL;
} else {
int err;
if ((err = prio_tune(sch, opt)) != 0)
return err;
}
return 0;
}
static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
{
struct prio_sched_data *q = qdisc_priv(sch);
unsigned char *b = skb_tail_pointer(skb);
struct tc_prio_qopt opt;
opt.bands = q->bands;
memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
return skb->len;
nla_put_failure:
nlmsg_trim(skb, b);
return -1;
}
static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
struct Qdisc **old)
{
struct prio_sched_data *q = qdisc_priv(sch);
unsigned long band = arg - 1;
if (new == NULL)
new = &noop_qdisc;
sch_tree_lock(sch);
*old = q->queues[band];
q->queues[band] = new;
qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
qdisc_reset(*old);
sch_tree_unlock(sch);
return 0;
}
static struct Qdisc *
prio_leaf(struct Qdisc *sch, unsigned long arg)
{
struct prio_sched_data *q = qdisc_priv(sch);
unsigned long band = arg - 1;
return q->queues[band];
}
static unsigned long prio_get(struct Qdisc *sch, u32 classid)
{
struct prio_sched_data *q = qdisc_priv(sch);
unsigned long band = TC_H_MIN(classid);
if (band - 1 >= q->bands)
return 0;
return band;
}
static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
{
return prio_get(sch, classid);
}
static void prio_put(struct Qdisc *q, unsigned long cl)
{
}
static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
struct tcmsg *tcm)
{
struct prio_sched_data *q = qdisc_priv(sch);
tcm->tcm_handle |= TC_H_MIN(cl);
tcm->tcm_info = q->queues[cl-1]->handle;
return 0;
}
static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
struct gnet_dump *d)
{
struct prio_sched_data *q = qdisc_priv(sch);
struct Qdisc *cl_q;
cl_q = q->queues[cl - 1];
cl_q->qstats.qlen = cl_q->q.qlen;
if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 ||
gnet_stats_copy_queue(d, &cl_q->qstats) < 0)
return -1;
return 0;
}
static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
{
struct prio_sched_data *q = qdisc_priv(sch);
int prio;
if (arg->stop)
return;
for (prio = 0; prio < q->bands; prio++) {
if (arg->count < arg->skip) {
arg->count++;
continue;
}
if (arg->fn(sch, prio + 1, arg) < 0) {
arg->stop = 1;
break;
}
arg->count++;
}
}
static struct tcf_proto **prio_find_tcf(struct Qdisc *sch, unsigned long cl)
{
struct prio_sched_data *q = qdisc_priv(sch);
if (cl)
return NULL;
return &q->filter_list;
}
static const struct Qdisc_class_ops prio_class_ops = {
.graft = prio_graft,
.leaf = prio_leaf,
.get = prio_get,
.put = prio_put,
.walk = prio_walk,
.tcf_chain = prio_find_tcf,
.bind_tcf = prio_bind,
.unbind_tcf = prio_put,
.dump = prio_dump_class,
.dump_stats = prio_dump_class_stats,
};
static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
.next = NULL,
.cl_ops = &prio_class_ops,
.id = "prio",
.priv_size = sizeof(struct prio_sched_data),
.enqueue = prio_enqueue,
.dequeue = prio_dequeue,
.peek = prio_peek,
.drop = prio_drop,
.init = prio_init,
.reset = prio_reset,
.destroy = prio_destroy,
.change = prio_tune,
.dump = prio_dump,
.owner = THIS_MODULE,
};
static int __init prio_module_init(void)
{
return register_qdisc(&prio_qdisc_ops);
}
static void __exit prio_module_exit(void)
{
unregister_qdisc(&prio_qdisc_ops);
}
module_init(prio_module_init)
module_exit(prio_module_exit)
MODULE_LICENSE("GPL");
|
174754.c | #include "clapack.h"
/* Subroutine */ int ssymv_(char *uplo, integer *n, real *alpha, real *a,
integer *lda, real *x, integer *incx, real *beta, real *y, integer *
incy)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2;
/* Local variables */
integer i__, j, ix, iy, jx, jy, kx, ky, info;
real temp1, temp2;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int xerbla_(char *, integer *);
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SSYMV performs the matrix-vector operation */
/* y := alpha*A*x + beta*y, */
/* where alpha and beta are scalars, x and y are n element vectors and */
/* A is an n by n symmetric matrix. */
/* Arguments */
/* ========== */
/* UPLO - CHARACTER*1. */
/* On entry, UPLO specifies whether the upper or lower */
/* triangular part of the array A is to be referenced as */
/* follows: */
/* UPLO = 'U' or 'u' Only the upper triangular part of A */
/* is to be referenced. */
/* UPLO = 'L' or 'l' Only the lower triangular part of A */
/* is to be referenced. */
/* Unchanged on exit. */
/* N - INTEGER. */
/* On entry, N specifies the order of the matrix A. */
/* N must be at least zero. */
/* Unchanged on exit. */
/* ALPHA - REAL . */
/* On entry, ALPHA specifies the scalar alpha. */
/* Unchanged on exit. */
/* A - REAL array of DIMENSION ( LDA, n ). */
/* Before entry with UPLO = 'U' or 'u', the leading n by n */
/* upper triangular part of the array A must contain the upper */
/* triangular part of the symmetric matrix and the strictly */
/* lower triangular part of A is not referenced. */
/* Before entry with UPLO = 'L' or 'l', the leading n by n */
/* lower triangular part of the array A must contain the lower */
/* triangular part of the symmetric matrix and the strictly */
/* upper triangular part of A is not referenced. */
/* Unchanged on exit. */
/* LDA - INTEGER. */
/* On entry, LDA specifies the first dimension of A as declared */
/* in the calling (sub) program. LDA must be at least */
/* max( 1, n ). */
/* Unchanged on exit. */
/* X - REAL array of dimension at least */
/* ( 1 + ( n - 1 )*abs( INCX ) ). */
/* Before entry, the incremented array X must contain the n */
/* element vector x. */
/* Unchanged on exit. */
/* INCX - INTEGER. */
/* On entry, INCX specifies the increment for the elements of */
/* X. INCX must not be zero. */
/* Unchanged on exit. */
/* BETA - REAL . */
/* On entry, BETA specifies the scalar beta. When BETA is */
/* supplied as zero then Y need not be set on input. */
/* Unchanged on exit. */
/* Y - REAL array of dimension at least */
/* ( 1 + ( n - 1 )*abs( INCY ) ). */
/* Before entry, the incremented array Y must contain the n */
/* element vector y. On exit, Y is overwritten by the updated */
/* vector y. */
/* INCY - INTEGER. */
/* On entry, INCY specifies the increment for the elements of */
/* Y. INCY must not be zero. */
/* Unchanged on exit. */
/* Level 2 Blas routine. */
/* -- Written on 22-October-1986. */
/* Jack Dongarra, Argonne National Lab. */
/* Jeremy Du Croz, Nag Central Office. */
/* Sven Hammarling, Nag Central Office. */
/* Richard Hanson, Sandia National Labs. */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* Test the input parameters. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--x;
--y;
/* Function Body */
info = 0;
if (! lsame_(uplo, "U") && ! lsame_(uplo, "L")) {
info = 1;
} else if (*n < 0) {
info = 2;
} else if (*lda < max(1,*n)) {
info = 5;
} else if (*incx == 0) {
info = 7;
} else if (*incy == 0) {
info = 10;
}
if (info != 0) {
xerbla_("SSYMV ", &info);
return 0;
}
/* Quick return if possible. */
if (*n == 0 || *alpha == 0.f && *beta == 1.f) {
return 0;
}
/* Set up the start points in X and Y. */
if (*incx > 0) {
kx = 1;
} else {
kx = 1 - (*n - 1) * *incx;
}
if (*incy > 0) {
ky = 1;
} else {
ky = 1 - (*n - 1) * *incy;
}
/* Start the operations. In this version the elements of A are */
/* accessed sequentially with one pass through the triangular part */
/* of A. */
/* First form y := beta*y. */
if (*beta != 1.f) {
if (*incy == 1) {
if (*beta == 0.f) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
y[i__] = 0.f;
/* L10: */
}
} else {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
y[i__] = *beta * y[i__];
/* L20: */
}
}
} else {
iy = ky;
if (*beta == 0.f) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
y[iy] = 0.f;
iy += *incy;
/* L30: */
}
} else {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
y[iy] = *beta * y[iy];
iy += *incy;
/* L40: */
}
}
}
}
if (*alpha == 0.f) {
return 0;
}
if (lsame_(uplo, "U")) {
/* Form y when A is stored in upper triangle. */
if (*incx == 1 && *incy == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp1 = *alpha * x[j];
temp2 = 0.f;
i__2 = j - 1;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__] += temp1 * a[i__ + j * a_dim1];
temp2 += a[i__ + j * a_dim1] * x[i__];
/* L50: */
}
y[j] = y[j] + temp1 * a[j + j * a_dim1] + *alpha * temp2;
/* L60: */
}
} else {
jx = kx;
jy = ky;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp1 = *alpha * x[jx];
temp2 = 0.f;
ix = kx;
iy = ky;
i__2 = j - 1;
for (i__ = 1; i__ <= i__2; ++i__) {
y[iy] += temp1 * a[i__ + j * a_dim1];
temp2 += a[i__ + j * a_dim1] * x[ix];
ix += *incx;
iy += *incy;
/* L70: */
}
y[jy] = y[jy] + temp1 * a[j + j * a_dim1] + *alpha * temp2;
jx += *incx;
jy += *incy;
/* L80: */
}
}
} else {
/* Form y when A is stored in lower triangle. */
if (*incx == 1 && *incy == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp1 = *alpha * x[j];
temp2 = 0.f;
y[j] += temp1 * a[j + j * a_dim1];
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
y[i__] += temp1 * a[i__ + j * a_dim1];
temp2 += a[i__ + j * a_dim1] * x[i__];
/* L90: */
}
y[j] += *alpha * temp2;
/* L100: */
}
} else {
jx = kx;
jy = ky;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp1 = *alpha * x[jx];
temp2 = 0.f;
y[jy] += temp1 * a[j + j * a_dim1];
ix = jx;
iy = jy;
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
ix += *incx;
iy += *incy;
y[iy] += temp1 * a[i__ + j * a_dim1];
temp2 += a[i__ + j * a_dim1] * x[ix];
/* L110: */
}
y[jy] += *alpha * temp2;
jx += *incx;
jy += *incy;
/* L120: */
}
}
}
return 0;
/* End of SSYMV . */
} /* ssymv_ */
|
153012.c | /* iowin32.c -- IO base function header for compress/uncompress .zip
Version 1.1, February 14h, 2010
part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
For more info read MiniZip_info.txt
*/
#include <stdlib.h>
#include "zlib.h"
#include "ioapi.h"
#include "iowin32.h"
#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
#endif
#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
voidpf ZCALLBACK win32_open_file_func OF((voidpf opaque, const char* filename, int mode));
uLong ZCALLBACK win32_read_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
uLong ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
ZPOS64_T ZCALLBACK win32_tell64_file_func OF((voidpf opaque, voidpf stream));
long ZCALLBACK win32_seek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
int ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
int ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
typedef struct
{
HANDLE hf;
int error;
} WIN32FILE_IOWIN;
static void win32_translate_open_mode(int mode,
DWORD* lpdwDesiredAccess,
DWORD* lpdwCreationDisposition,
DWORD* lpdwShareMode,
DWORD* lpdwFlagsAndAttributes)
{
*lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
{
*lpdwDesiredAccess = GENERIC_READ;
*lpdwCreationDisposition = OPEN_EXISTING;
*lpdwShareMode = FILE_SHARE_READ;
}
else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
{
*lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
*lpdwCreationDisposition = OPEN_EXISTING;
}
else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
{
*lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
*lpdwCreationDisposition = CREATE_ALWAYS;
}
}
static voidpf win32_build_iowin(HANDLE hFile)
{
voidpf ret=NULL;
if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
{
WIN32FILE_IOWIN w32fiow;
w32fiow.hf = hFile;
w32fiow.error = 0;
ret = malloc(sizeof(WIN32FILE_IOWIN));
if (ret==NULL)
CloseHandle(hFile);
else
*((WIN32FILE_IOWIN*)ret) = w32fiow;
}
return ret;
}
voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
{
const char* mode_fopen = NULL;
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
HANDLE hFile = NULL;
win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
if ((filename!=NULL) && (dwDesiredAccess != 0))
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
return win32_build_iowin(hFile);
}
voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
{
const char* mode_fopen = NULL;
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
HANDLE hFile = NULL;
win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
if ((filename!=NULL) && (dwDesiredAccess != 0))
hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
return win32_build_iowin(hFile);
}
voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
{
const char* mode_fopen = NULL;
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
HANDLE hFile = NULL;
win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
if ((filename!=NULL) && (dwDesiredAccess != 0))
hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
return win32_build_iowin(hFile);
}
voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
{
const char* mode_fopen = NULL;
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
HANDLE hFile = NULL;
win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
if ((filename!=NULL) && (dwDesiredAccess != 0))
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
return win32_build_iowin(hFile);
}
uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
{
uLong ret=0;
HANDLE hFile = NULL;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL)
{
if (!ReadFile(hFile, buf, size, &ret, NULL))
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_HANDLE_EOF)
dwErr = 0;
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
}
}
return ret;
}
uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
{
uLong ret=0;
HANDLE hFile = NULL;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL)
{
if (!WriteFile(hFile, buf, size, &ret, NULL))
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_HANDLE_EOF)
dwErr = 0;
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
}
}
return ret;
}
long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
{
long ret=-1;
HANDLE hFile = NULL;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL)
{
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
if (dwSet == INVALID_SET_FILE_POINTER)
{
DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = -1;
}
else
ret=(long)dwSet;
}
return ret;
}
ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
{
ZPOS64_T ret= (ZPOS64_T)-1;
HANDLE hFile = NULL;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream)->hf;
if (hFile)
{
LARGE_INTEGER li;
li.QuadPart = 0;
li.u.LowPart = SetFilePointer(hFile, li.u.LowPart, &li.u.HighPart, FILE_CURRENT);
if ( (li.LowPart == 0xFFFFFFFF) && (GetLastError() != NO_ERROR))
{
DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = (ZPOS64_T)-1;
}
else
ret=li.QuadPart;
}
return ret;
}
long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
{
DWORD dwMoveMethod=0xFFFFFFFF;
HANDLE hFile = NULL;
long ret=-1;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
switch (origin)
{
case ZLIB_FILEFUNC_SEEK_CUR :
dwMoveMethod = FILE_CURRENT;
break;
case ZLIB_FILEFUNC_SEEK_END :
dwMoveMethod = FILE_END;
break;
case ZLIB_FILEFUNC_SEEK_SET :
dwMoveMethod = FILE_BEGIN;
break;
default: return -1;
}
if (hFile != NULL)
{
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
if (dwSet == INVALID_SET_FILE_POINTER)
{
DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = -1;
}
else
ret=0;
}
return ret;
}
long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
{
DWORD dwMoveMethod=0xFFFFFFFF;
HANDLE hFile = NULL;
long ret=-1;
if (stream!=NULL)
hFile = ((WIN32FILE_IOWIN*)stream)->hf;
switch (origin)
{
case ZLIB_FILEFUNC_SEEK_CUR :
dwMoveMethod = FILE_CURRENT;
break;
case ZLIB_FILEFUNC_SEEK_END :
dwMoveMethod = FILE_END;
break;
case ZLIB_FILEFUNC_SEEK_SET :
dwMoveMethod = FILE_BEGIN;
break;
default: return -1;
}
if (hFile)
{
LARGE_INTEGER* li = (LARGE_INTEGER*)&offset;
DWORD dwSet = SetFilePointer(hFile, li->u.LowPart, &li->u.HighPart, dwMoveMethod);
if (dwSet == INVALID_SET_FILE_POINTER)
{
DWORD dwErr = GetLastError();
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
ret = -1;
}
else
ret=0;
}
return ret;
}
int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
{
int ret=-1;
if (stream!=NULL)
{
HANDLE hFile;
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
if (hFile != NULL)
{
CloseHandle(hFile);
ret=0;
}
free(stream);
}
return ret;
}
int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
{
int ret=-1;
if (stream!=NULL)
{
ret = ((WIN32FILE_IOWIN*)stream) -> error;
}
return ret;
}
void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
{
pzlib_filefunc_def->zopen_file = win32_open_file_func;
pzlib_filefunc_def->zread_file = win32_read_file_func;
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
pzlib_filefunc_def->ztell_file = win32_tell_file_func;
pzlib_filefunc_def->zseek_file = win32_seek_file_func;
pzlib_filefunc_def->zclose_file = win32_close_file_func;
pzlib_filefunc_def->zerror_file = win32_error_file_func;
pzlib_filefunc_def->opaque = NULL;
}
void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
{
pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
pzlib_filefunc_def->zread_file = win32_read_file_func;
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
pzlib_filefunc_def->zclose_file = win32_close_file_func;
pzlib_filefunc_def->zerror_file = win32_error_file_func;
pzlib_filefunc_def->opaque = NULL;
}
void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
{
pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
pzlib_filefunc_def->zread_file = win32_read_file_func;
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
pzlib_filefunc_def->zclose_file = win32_close_file_func;
pzlib_filefunc_def->zerror_file = win32_error_file_func;
pzlib_filefunc_def->opaque = NULL;
}
void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
{
pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
pzlib_filefunc_def->zread_file = win32_read_file_func;
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
pzlib_filefunc_def->zclose_file = win32_close_file_func;
pzlib_filefunc_def->zerror_file = win32_error_file_func;
pzlib_filefunc_def->opaque = NULL;
}
|
926971.c | // SPDX-License-Identifier: BSD-3-Clause
/*
* Copyright (C) Foundries Ltd. 2020 - All Rights Reserved
* Author: Jorge Ramirez <[email protected]>
*/
#include <crypto/crypto.h>
#include <se050.h>
#include <string.h>
#define BIT(nr) (1UL << (nr))
/* base value for secure objects (transient and persistent) */
#define OID_MIN ((uint32_t)(0x00000001))
#define OID_MAX ((uint32_t)(OID_MIN + 0x7BFFFFFE))
#define NBR_OID ((uint32_t)(OID_MAX - OID_MIN))
#define IS_WATERMARKED(x) (((x) & WATERMARKED(0)) == WATERMARKED(0))
static void delete_transient_objects(void)
{
Se05xSession_t *ctx = NULL;
uint8_t more = kSE05x_MoreIndicator_NA;
uint8_t *list = NULL;
size_t len = 1024;
smStatus_t status = SM_NOT_OK;
uint16_t offset = 0;
uint32_t id = 0;
size_t nbr_pobj = 0, nbr_tobj = 0;
size_t i = 0;
if (!se050_session)
return;
ctx = &se050_session->s_ctx;
list = calloc(1, len);
if (!list)
return;
do {
status = Se05x_API_ReadIDList(ctx, offset, 0xFF, &more,
list, &len);
if (status != SM_OK) {
free(list);
return;
}
offset = len;
for (i = 0; i < len; i += 4) {
id = (list[i + 0] << (3 * 8)) |
(list[i + 1] << (2 * 8)) |
(list[i + 2] << (1 * 8)) |
(list[i + 3] << (0 * 8));
if (id >= OID_MAX || id == 0)
continue;
/* delete only transient objects */
if (id & BIT(0)) {
status = Se05x_API_DeleteSecureObject(ctx, id);
if (status != SM_OK) {
EMSG("Error erasing 0x%x", id);
} else {
nbr_tobj++;
DMSG("Erased 0x%x", id);
}
} else {
nbr_pobj++;
}
}
} while (more == kSE05x_MoreIndicator_MORE);
DMSG("Permanent objects in store %ld", nbr_pobj);
IMSG("Transient objects deleted %ld", nbr_tobj);
free(list);
}
static uint32_t generate_oid(sss_key_object_mode_t mode)
{
uint32_t oid = OID_MIN;
uint32_t random = 0;
size_t i = 0;
for (i = 0; i < NBR_OID; i++) {
if (crypto_rng_read(&random, sizeof(random)) != TEE_SUCCESS)
return 0;
random &= OID_MAX;
oid = OID_MIN + random;
if (oid > OID_MAX)
continue;
if (mode == kKeyObject_Mode_Transient)
oid |= BIT(0);
else
oid &= ~BIT(0);
if (!se050_key_exists(oid, &se050_session->s_ctx))
return oid;
}
return 0;
}
/*
*
* @param mode
* @param val
*
* @return sss_status_t
*/
sss_status_t se050_get_oid(sss_key_object_mode_t mode, uint32_t *val)
{
sss_status_t status = kStatus_SSS_Success;
uint16_t mem_t = 0, mem_p = 0;
uint32_t oid = 0;
if (!val)
return kStatus_SSS_Fail;
status = se050_get_free_memory(&se050_session->s_ctx, &mem_t,
kSE05x_MemoryType_TRANSIENT_DESELECT);
if (status != kStatus_SSS_Success) {
mem_t = 0;
EMSG("failure retrieving transient free memory");
return kStatus_SSS_Fail;
}
status = se050_get_free_memory(&se050_session->s_ctx, &mem_p,
kSE05x_MemoryType_PERSISTENT);
if (status != kStatus_SSS_Success) {
mem_p = 0;
EMSG("failure retrieving persistent free memory");
return kStatus_SSS_Fail;
}
/*
* rsa: when the ammount of memory falls below these
* thresholds, we can no longer store RSA 2048 keys in the SE050
* meaning that we can no longer open a TA.
*
*/
if (mem_t < 0x140) {
IMSG("low memory threshold hit, releasing transient memory");
IMSG("free mem persistent 0x%x, transient 0x%x", mem_p, mem_t);
delete_transient_objects();
}
oid = generate_oid(mode);
if (!oid) {
EMSG("cant access rng");
return kStatus_SSS_Fail;
}
*val = oid;
return kStatus_SSS_Success;
}
static uint32_t se050_key(uint64_t key)
{
uint32_t oid = (uint32_t)key;
if (!IS_WATERMARKED(key))
return 0;
if (oid < OID_MIN || oid > OID_MAX)
return 0;
return oid;
}
uint32_t se050_rsa_keypair_from_nvm(struct rsa_keypair *key)
{
uint64_t key_id = 0;
if (!key)
return 0;
if (crypto_bignum_num_bytes(key->d) != sizeof(uint64_t))
return 0;
crypto_bignum_bn2bin(key->d, (uint8_t *)&key_id);
return se050_key(key_id);
}
uint32_t se050_ecc_keypair_from_nvm(struct ecc_keypair *key)
{
uint64_t key_id = 0;
if (!key)
return 0;
if (crypto_bignum_num_bytes(key->d) != sizeof(uint64_t))
return 0;
crypto_bignum_bn2bin(key->d, (uint8_t *)&key_id);
return se050_key(key_id);
}
uint64_t se050_generate_private_key(uint32_t oid)
{
return WATERMARKED(oid);
}
/*
* Parse a DER formated signature and extract the raw data
* @param p
* @param p_len
*/
void se050_signature_der2bin(uint8_t *p, size_t *p_len)
{
uint8_t buffer[256] = { 0 };
uint8_t *k, *output = p;
size_t buffer_len = 0;
size_t len = 0;
if (!p || !p_len)
return;
p++; /* tag: 0x30 */
p++; /* field: total len */
p++; /* tag: 0x02 */
len = *p++; /* field: r_len */
if (*p == 0x00) { /* handle special case */
len = len - 1;
p++;
}
memcpy(buffer, p, len);
p = p + len;
p++; /* tag: 0x2 */
k = p;
p++; /* field: s_len */
if (*p == 0x00) { /* handle special case */
*k = *k - 1;
p++;
}
memcpy(buffer + len, p, *k);
buffer_len = len + *k;
memcpy(output, buffer, buffer_len);
*p_len = buffer_len;
}
/*
* @param signature
* @param signature_len
* @param raw
* @param raw_len
*/
sss_status_t se050_signature_bin2der(uint8_t *signature, size_t *signature_len,
uint8_t *raw, size_t raw_len)
{
size_t der_len = 6 + raw_len;
size_t r_len = raw_len / 2;
size_t s_len = raw_len / 2;
if (*signature_len < der_len) {
EMSG("ECDAA Signature buffer overflow");
return kStatus_SSS_Fail;
}
if (raw_len != 48 && raw_len != 56 && raw_len != 64 && raw_len != 96) {
EMSG("ECDAA Invalid length in bin signature %ld", raw_len);
return kStatus_SSS_Fail;
}
*signature_len = der_len;
signature[0] = 0x30;
signature[1] = (uint8_t)(raw_len + 4);
signature[2] = 0x02;
signature[3] = (uint8_t)r_len;
memcpy(&signature[4], &raw[0], r_len);
signature[3 + r_len + 1] = 0x02;
signature[3 + r_len + 2] = (uint8_t)s_len;
memcpy(&signature[3 + r_len + 3], &raw[r_len], s_len);
return kStatus_SSS_Success;
}
/*
* @param cnt
*/
void se050_refcount_init_ctx(uint8_t **cnt)
{
if (!*cnt) {
*cnt = calloc(1, sizeof(uint8_t));
if (*cnt)
**cnt = 1;
} else {
**cnt = **cnt + 1;
}
}
/*
* @param cnt
*
* @return int
*/
int se050_refcount_final_ctx(uint8_t *cnt)
{
if (!cnt)
return 1;
if (!*cnt) {
free(cnt);
return 1;
}
*cnt = *cnt - 1;
return 0;
}
|
313240.c | //#############################################################################
//
// FILE: led_ex1_blinky_cpu1.c
//
// TITLE: LED Blinky Example
//
//! \addtogroup driver_dual_example_list
//! <h1> LED Blinky Example</h1>
//!
//! This example demonstrates how to blink a LED using CPU1 and blink another
//! LED using CPU2 (led_ex1_blinky_cpu2.c).
//!
//! \b External \b Connections \n
//! - None.
//!
//! \b Watch \b Variables \n
//! - None.
//!
//
//#############################################################################
// $TI Release: F2837xD Support Library v3.05.00.00 $
// $Release Date: Thu Oct 18 15:48:42 CDT 2018 $
// $Copyright:
// Copyright (C) 2013-2018 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################
//
// Included Files
//
#include "driverlib.h"
#include "device.h"
//
// Main
//
void main(void)
{
//
// Initialize device clock and peripherals
//
Device_init();
//
// Initialize GPIO and configure the GPIO pin as a push-pull output
//
Device_initGPIO();
GPIO_setPadConfig(DEVICE_GPIO_PIN_LED1, GPIO_PIN_TYPE_STD);
GPIO_setDirectionMode(DEVICE_GPIO_PIN_LED1, GPIO_DIR_MODE_OUT);
GPIO_setPadConfig(DEVICE_GPIO_PIN_LED2, GPIO_PIN_TYPE_STD);
GPIO_setDirectionMode(DEVICE_GPIO_PIN_LED2, GPIO_DIR_MODE_OUT);
//
// Configure CPU2 to control the LED GPIO
//
GPIO_setMasterCore(DEVICE_GPIO_PIN_LED2, GPIO_CORE_CPU2);
//
// Initialize PIE and clear PIE registers. Disables CPU interrupts.
//
Interrupt_initModule();
//
// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
//
Interrupt_initVectorTable();
//
// Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
//
EINT;
ERTM;
//
// Loop Forever
//
for(;;)
{
//
// Turn on LED
//
GPIO_writePin(DEVICE_GPIO_PIN_LED1, 0);
//
// Delay for a bit.
//
DEVICE_DELAY_US(500000);
//
// Turn off LED
//
GPIO_writePin(DEVICE_GPIO_PIN_LED1, 1);
//
// Delay for a bit.
//
DEVICE_DELAY_US(500000);
}
}
//
// End of File
//
|