static void
test_lexer_others(void)
{
_input("#This is a full line comment\nfoobar");
assert_parser_identifier("foobar");
_input("@version");
assert_parser_pragma(parser);
assert_parser_identifier("version");
_input("():;{}|");
assert_parser_char('(');
assert_parser_char(')');
assert_parser_char(':');
assert_parser_char(';');
assert_parser_char('{');
assert_parser_char('}');
assert_parser_char('|');
_input("4.2 12 0x50 011 +12 -12 -4.2 +4.2");
assert_parser_float(4.2);
assert_parser_number(12);
assert_parser_number(80 /*0x50*/);
assert_parser_number(9 /*011 */);
assert_parser_number(12);
assert_parser_number(-12);
assert_parser_float(-4.2);
assert_parser_float(4.2);
_input("test_value");
assert_parser_identifier("test_value");
}
static void
test_lexer_qstring(void)
{
_input("'test'");
assert_parser_string("test");
_input("'\"test\\n\\r\"'");
assert_parser_string("\"test\\n\\r\"");
}
static void
test_lexer_block(void)
{
_input(TEST_BLOCK);
cfg_lexer_start_block_state(parser->lexer, "{}");
assert_parser_block("'hello world' \"test value\" {other_block} other\text");
_input(TEST_BAD_BLOCK);
cfg_lexer_start_block_state(parser->lexer, "{}");
assert_parser_block_bad(parser);
}
static void
test_lexer_string(void)
{
_input("\"test\"");
assert_parser_string("test");
_input("\"test\\x0a\"");
assert_parser_string("test\n");
_input("\"test\\o011\"");
assert_parser_string("test\t");
_input("\"test\\n\\r\\a\\t\\v\\c\"");
assert_parser_string("test\n\r\a\t\vc");
}
std::map< GRINS::PhysicsName, GRINS::NBCContainer > GRINS::ThermallyDrivenFlowTestBCFactory::build_neumann( libMesh::EquationSystems& es )
{
std::map< std::string, GRINS::NBCContainer > nbcs;
/* Hack to work around the fact that we're using this test for the axisymmetric
case as well the fact I'm and idiot in the design of the axisymmetric cases. */
if( _input("Physics/enabled_physics", "DIE!", 1) != std::string("HeatTransfer") )
{
// Do nothing.
}
else
{
// These are hardcoded for the 2D and 3D tests, *not* the axisymmetric test.
const libMesh::System& system = es.get_system("GRINS");
const GRINS::VariableIndex T_var = system.variable_number("T");
GRINS::SharedPtr<GRINS::NeumannFuncObj> func( new ZeroFluxBC );
GRINS::NBCContainer nbc_container;
nbc_container.set_bc_id(0);
nbc_container.add_var_func_pair( T_var, func );
nbcs.insert( std::pair< std::string, GRINS::NBCContainer >( "HeatTransfer", nbc_container ) );
}
return nbcs;
}
// set image so that we can start computation
void
Auvsi_Recognize::setImage( cv::Mat img )
{
// Set equal to image
cv::Mat _input( img );
cv::Mat temp2( _input.size(), CV_32F );
_image = cv::Mat( IMAGE_HEIGHT, IMAGE_WIDTH, CV_32F );
_input.convertTo( temp2, _image.type(), 1.0/255.0f );
cv::imshow( "Input", _input );
cv::resize(temp2, _image, _image.size() );
cv::cvtColor( _image, _image, CV_RGB2Lab );
//std::printf("converted color in set image \n");
// Only use A and B channels
#ifdef TWO_CHANNEL
std::vector<cv::Mat> splitData;
cv::split( _image, splitData );
splitData.erase( splitData.begin() );
cv::merge( splitData, _image );
#endif
}
static void _event_handler(telnet_t *telnet, telnet_event_t *ev,
void *user_data) {
struct user_t *user = (struct user_t*)user_data;
switch (ev->type) {
/* data received */
case TELNET_EV_DATA:
_input(user, ev->data.buffer, ev->data.size);
break;
/* data must be sent */
case TELNET_EV_SEND:
_send(user->sock, ev->data.buffer, ev->data.size);
break;
/* enable compress2 if accepted by client */
case TELNET_EV_DO:
if (ev->neg.telopt == TELNET_TELOPT_COMPRESS2)
telnet_begin_compress2(telnet);
break;
/* error */
case TELNET_EV_ERROR:
close(user->sock);
user->sock = -1;
if (user->name != 0) {
_message(user->name, "** HAS HAD AN ERROR **");
free(user->name);
user->name = 0;
}
telnet_free(user->telnet);
break;
default:
/* ignore */
break;
}
}
int main(int argc, char* argv[])
{
LIST l;
_input("data.txt",l);
output("data.inp",l);
if (!input("data.inp",l)==0)
{
printf("Khong mo duoc file");
return 1;
}
printf("Xuat danh sach:\n");
output(l);
printf("\nNhap ten dai ly muon tim kiem:");
fflush(stdin);
char s[31];
gets(s);
DAILY temp;
int kq1=timten(l,s,temp);
if (kq1)
{
xuat(temp);
}
else
printf("Khong tim thay dai ly co ten la %s",s);
DAILY k=timtiepnhan(l);
printf("\n\nDai ly duoc tiep nhan gan day nhat la:\n");
xuat(k);
output("data.out",l);
return 0;
}
int scanf(const char *fmt, ...)
{
int rc;
va_list args;
va_start(args, fmt);
rc = _input(stdin, fmt, args);
return rc;
}
int fscanf(FILE *stream, const char *fmt, ...)
{
int rc;
va_list args;
va_start(args, fmt);
rc = _input(stream, fmt, args);
return rc;
}
Input * List::addInput(Id const& _typeId)
{
std::unique_ptr<Input> _input(Factory::create(_typeId));
if (!_input) return nullptr;
container_type::emplace_back(std::move(_input));
return container_type::back().get();
}
int vsscanf(const char *buffer, const char *fmt, va_list args)
{
int rc;
FILE str;
str.flag = _IORD | _IOSTR | _IOOWNBUF;
str.ptr = str.base = (char *) buffer;
str.cnt = strlen(buffer);
rc = _input(&str, fmt, args);
return rc;
}
int __cdecl fscanf (
FILE *stream,
const char *format,
...
)
/*
* 'F'ile (stream) 'SCAN', 'F'ormatted
*/
{
int retval;
va_list arglist;
va_start(arglist, format);
_ASSERTE(stream != NULL);
_ASSERTE(format != NULL);
_lock_str(stream);
retval = (_input(stream,format,arglist));
_unlock_str(stream);
return(retval);
}
int __cdecl scanf (
const char *format,
...
)
/*
* stdin 'SCAN', 'F'ormatted
*/
{
int retval;
va_list arglist;
va_start(arglist, format);
_ASSERTE(format != NULL);
_lock_str2(0, stdin);
retval = (_input(stdin,format,arglist));
_unlock_str2(0, stdin);
return(retval);
}
int vfscanf(FILE *stream, const char *fmt, va_list args)
{
return _input(stream, fmt, args);
}
int main(int argc, char **argv) {
char buffer[512];
int rs;
int sock;
struct sockaddr_in addr;
struct pollfd pfd[2];
struct addrinfo *ai;
struct addrinfo hints;
struct termios tios;
/* check usage */
if (argc != 3) {
fprintf(stderr, "Usage:\n ./telnet-client <host> <port>\n");
return 1;
}
/* look up server host */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if ((rs = getaddrinfo(argv[1], argv[2], &hints, &ai)) != 0) {
fprintf(stderr, "getaddrinfo() failed for %s: %s\n", argv[1],
gai_strerror(rs));
return 1;
}
/* create server socket */
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "socket() failed: %s\n", strerror(errno));
return 1;
}
/* bind server socket */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
fprintf(stderr, "bind() failed: %s\n", strerror(errno));
return 1;
}
/* connect */
if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
fprintf(stderr, "connect() failed: %s\n", strerror(errno));
return 1;
}
/* free address lookup info */
freeaddrinfo(ai);
/* get current terminal settings, set raw mode, make sure we
* register atexit handler to restore terminal settings
*/
tcgetattr(STDOUT_FILENO, &orig_tios);
atexit(_cleanup);
tios = orig_tios;
cfmakeraw(&tios);
tcsetattr(STDOUT_FILENO, TCSADRAIN, &tios);
/* set input echoing on by default */
do_echo = 1;
/* initialize telnet box */
telnet = telnet_init(telopts, _event_handler, 0, &sock);
/* initialize poll descriptors */
memset(pfd, 0, sizeof(pfd));
pfd[0].fd = STDIN_FILENO;
pfd[0].events = POLLIN;
pfd[1].fd = sock;
pfd[1].events = POLLIN;
/* loop while both connections are open */
while (poll(pfd, 2, -1) != -1) {
/* read from stdin */
if (pfd[0].revents & POLLIN) {
if ((rs = read(STDIN_FILENO, buffer, sizeof(buffer))) > 0) {
_input(buffer, rs);
} else if (rs == 0) {
break;
} else {
fprintf(stderr, "recv(server) failed: %s\n",
strerror(errno));
exit(1);
}
}
/* read from client */
if (pfd[1].revents & POLLIN) {
if ((rs = recv(sock, buffer, sizeof(buffer), 0)) > 0) {
telnet_recv(telnet, buffer, rs);
} else if (rs == 0) {
break;
} else {
fprintf(stderr, "recv(client) failed: %s\n",
strerror(errno));
exit(1);
}
}
}
/* clean up */
telnet_free(telnet);
close(sock);
return 0;
}
int vscanf(const char *fmt, va_list args)
{
return _input(stdin, fmt, args);
}
