Пример #1
0
static int skip_code(parser_ctx_t *ctx, BOOL exec_else)
{
    int if_depth = 1;
    const WCHAR *ptr;

    while(1) {
        ptr = strchrW(ctx->ptr, '@');
        if(!ptr) {
            WARN("No @end\n");
            return lex_error(ctx, JS_E_EXPECTED_CCEND);
        }
        ctx->ptr = ptr+1;

        if(!check_keyword(ctx, endW, NULL)) {
            if(--if_depth)
                continue;
            return 0;
        }

        if(exec_else && !check_keyword(ctx, elifW, NULL)) {
            if(if_depth > 1)
                continue;

            if(!skip_spaces(ctx) || *ctx->ptr != '(')
                return lex_error(ctx, JS_E_MISSING_LBRACKET);

            if(!parse_cc_expr(ctx))
                return -1;

            if(!get_ccbool(ctx->ccval))
                continue; /* skip block of code */

            /* continue parsing */
            ctx->cc_if_depth++;
            return 0;
        }

        if(exec_else && !check_keyword(ctx, elseW, NULL)) {
            if(if_depth > 1)
                continue;

            /* parse else block */
            ctx->cc_if_depth++;
            return 0;
        }

        if(!check_keyword(ctx, ifW, NULL)) {
            if_depth++;
            continue;
        }

        ctx->ptr++;
    }
}
Пример #2
0
static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
{
    int min = 0, max = ARRAY_SIZE(keywords)-1, r, i;

    while(min <= max) {
        i = (min+max)/2;

        r = check_keyword(ctx, keywords[i].word, lval);
        if(!r) {
            if(ctx->script->version < keywords[i].min_version) {
                TRACE("ignoring keyword %s in incompatible mode\n",
                      debugstr_w(keywords[i].word));
                ctx->ptr -= strlenW(keywords[i].word);
                return 0;
            }
            ctx->implicit_nl_semicolon = keywords[i].no_nl;
            return keywords[i].token;
        }

        if(r > 0)
            min = i+1;
        else
            max = i-1;
    }

    return 0;
}
Пример #3
0
int jdfits_write_header_double (JDFits_Type *ft, char *name, double val, char *comment)
{
   char buf[JDFITS_CARD_SIZE + 1];
   char numbuf[64];
   int prec;

   if ((-1 == check_keyword (name))
       || (-1 == check_ascii(comment, 1)))
     return -1;

   /* According to the FITS NOST document, the resulting value should be right
    * justified in columns 11-30.  It must contain a decimal point and E must
    * be used if with in exponential form.
    */
   prec = 16;
   do
     {
	if (-1 == format_double (val, prec, numbuf))
	  {
	     strcpy (numbuf, "Floating point exception");
	     jdfits_warning ("jdfits_write_header_double: unable to convert value\n");
	     prec = 0;
	  }
	prec--;
	sprintf (buf, "%-8s= %20s", name, numbuf);
     }
   while ((prec > 5) && (strlen (buf) > 30));

   jdfits_append_comment (buf, comment);

   return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
}
Пример #4
0
void shell()
{
	char put_ch[2]={'0','\0'};
	char *p = NULL;
	char *str ="\rShell:~$";	

	for (;; cur_his = (cur_his + 1) % HISTORY_COUNT) {
		/* need use & that p can work correct, idk why p = cmd[cur_his] can't work */
		p = &cmd[cur_his][0];

		printf("%s",str);
		
		while (1) {
			//put_ch = receive_byte();			
			read(open("/dev/tty0/in", 0), put_ch, 1);

			if (put_ch[0] == '\r' || put_ch[0] == '\n') {
				*p = '\0';
				printf("%s",next_line);
				break;
			}
			else if (put_ch[0]== 127 || put_ch[0] == '\b') {
				if (p > &cmd[cur_his][0]) {
					p--;
					printf("\b \b");
				}
			}
			else if (p - &cmd[cur_his][0] < CMDBUF_SIZE - 1) {
				*(p++) = put_ch[0];
				printf("%c",put_ch[0]);
			}	
		}
		check_keyword();		
	}
}
Пример #5
0
int main(int argc, char *argv[])
{
    // Check the number of input parameters
    if (argc != 2)
    {
        printf("Incorrect number of command-line arguments specified.\n");
        
        return 1;
    }
    
    // Check the correctness of the keyword
    if (!check_keyword(argv[1]))
    {
        printf("Incorrect command-line argument specified.\n");
        
        return 1;        
    }
    
    // Input a plaintext string    
    char *str = GetString();
    
    // Encode the text with the Viginere cipher
    encode_viginere(str, argv[1]);
    
    //Output the string
    printf("%s\n", str);
    
    // Free the memory
    free(str);
    
    return 0;
}
Пример #6
0
 void GenPropertyVisitor::operator()(const Property &p) 
 {
     std::string kd = check_keyword(keywords_double, p.name);
     std::string ki = check_keyword(keywords_int, p.name);
     std::string ks = check_keyword(keywords_string, p.name);
     if (kd != "") {
         if (d_values.find(kd) != d_values.end()) THROW_EXC(ValueAlreadySet, "value already set");
         else d_values[kd] = p.get_double();
     }
     if (ki != "") {
         if (i_values.find(ki) != i_values.end()) THROW_EXC(ValueAlreadySet, "value already set");
         else i_values[ki] = p.get_int();
     }
     if (ks != "") {
         if (s_values.find(ks) != s_values.end()) THROW_EXC(ValueAlreadySet, "value already set");
         else s_values[ks] = p.get_value();
     }
 }
Пример #7
0
int try_parse_ccval(parser_ctx_t *ctx, ccval_t *r)
{
    if(!skip_spaces(ctx))
        return -1;

    if(isdigitW(*ctx->ptr)) {
        double n;

        if(!parse_numeric_literal(ctx, &n))
            return -1;

        *r = ccval_num(n);
        return 1;
    }

    if(*ctx->ptr == '@') {
        const WCHAR *ident;
        unsigned ident_len;
        cc_var_t *cc_var;

        if(!parse_cc_identifier(ctx, &ident, &ident_len))
            return -1;

        cc_var = find_cc_var(ctx->script->cc, ident, ident_len);
        *r = cc_var ? cc_var->val : ccval_num(NAN);
        return 1;
    }

    if(!check_keyword(ctx, trueW, NULL)) {
        *r = ccval_bool(TRUE);
        return 1;
    }

    if(!check_keyword(ctx, falseW, NULL)) {
        *r = ccval_bool(FALSE);
        return 1;
    }

    return 0;
}
Пример #8
0
Файл: lex.c Проект: mikekap/wine
static int cc_token(parser_ctx_t *ctx, void *lval)
{
    unsigned id_len = 0;
    cc_var_t *var;

    static const WCHAR cc_onW[] = {'c','c','_','o','n',0};
    static const WCHAR setW[] = {'s','e','t',0};
    static const WCHAR elifW[] = {'e','l','i','f',0};
    static const WCHAR endW[] = {'e','n','d',0};

    ctx->ptr++;

    if(!check_keyword(ctx, cc_onW, NULL))
        return init_cc(ctx);

    if(!check_keyword(ctx, setW, NULL)) {
        FIXME("@set not implemented\n");
        return lex_error(ctx, E_NOTIMPL);
    }

    if(!check_keyword(ctx, ifW, NULL)) {
        FIXME("@if not implemented\n");
        return lex_error(ctx, E_NOTIMPL);
    }

    if(!check_keyword(ctx, elifW, NULL)) {
        FIXME("@elif not implemented\n");
        return lex_error(ctx, E_NOTIMPL);
    }

    if(!check_keyword(ctx, elseW, NULL)) {
        FIXME("@else not implemented\n");
        return lex_error(ctx, E_NOTIMPL);
    }

    if(!check_keyword(ctx, endW, NULL)) {
        FIXME("@end not implemented\n");
        return lex_error(ctx, E_NOTIMPL);
    }

    if(!ctx->script->cc)
        return lex_error(ctx, JS_E_DISABLED_CC);

    while(ctx->ptr+id_len < ctx->end && is_identifier_char(ctx->ptr[id_len]))
        id_len++;
    if(!id_len)
        return '@';

    TRACE("var %s\n", debugstr_wn(ctx->ptr, id_len));

    var = find_cc_var(ctx->script->cc, ctx->ptr, id_len);
    ctx->ptr += id_len;
    if(!var || var->is_num) {
        *(literal_t**)lval = new_double_literal(ctx, var ? var->u.n : ret_nan());
        return tNumericLiteral;
    }

    *(literal_t**)lval = new_boolean_literal(ctx, var->u.b);
    return tBooleanLiteral;
}
Пример #9
0
int jdfits_write_header_integer (JDFits_Type *ft, char *name, int val, char *comment)
{
   char buf[JDFITS_CARD_SIZE + 1];

   if ((-1 == check_keyword (name))
       || (-1 == check_ascii(comment, 1)))
     return -1;

   sprintf (buf, "%-8s= %20d", name, val);
   jdfits_append_comment (buf, comment);

   return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
}
Пример #10
0
void serial_test_task(void* arg)
{
	char put_ch[2]={'0','\0'};
	char hint[] =  USER_NAME "@" USER_NAME "-STM32:~$ ";
	int hint_length = sizeof(hint);
	char *p = NULL;

	fdout = mq_open("/tmp/mqueue/out", O_CREAT);
	fdin = open("/dev/tty0/in", 0);

	for (;; cur_his = (cur_his + 1) % HISTORY_COUNT) {
		p = cmd[cur_his];
		write(fdout, hint, hint_length);

		while (1) {
			read(fdin, put_ch, 1);
			key_count++;
			if (put_ch[0] == '\r' || put_ch[0] == '\n') {
				*p = '\0';
				write(fdout, next_line, 3);
				break;
			}
			else if (put_ch[0] == 127 || put_ch[0] == '\b') {
				if (p > cmd[cur_his] && key_count) {
					p--;
					write(fdout, "\b \b", 4);
					key_count--;
				}
			}
			else if (p - cmd[cur_his] < CMDBUF_SIZE - 1) {
				*p++ = put_ch[0];
				write(fdout, put_ch, 2);
				/*	press keyboard 'up' show last history	*/
				if(key_count > 2 && !strncmp(p-3, keyup, 3)){
					write(fdout, keydown, 4);
					key_count -= 3;
					show_keyup();
					p = cmd[cur_his] + key_count;
					continue;
				}
			}
		}
		key_count = 0;
		check_keyword();	
	}
}
Пример #11
0
void lexA(){

	f.open(file, ifstream::in);
	
	skip_blanks();
	
	char peek = f.peek();

	if( is_number(peek) ){
		get_number(peek);	
	}else if( is_char(peek) ){
		check_keyword(peek);
	}else if( is_special(peek) ){
		handle_special(peek);
	}else{
		get_identifier();
	}
	
}
Пример #12
0
Файл: lex.c Проект: mikekap/wine
static int check_keywords(parser_ctx_t *ctx, const WCHAR **lval)
{
    int min = 0, max = sizeof(keywords)/sizeof(keywords[0])-1, r, i;

    while(min <= max) {
        i = (min+max)/2;

        r = check_keyword(ctx, keywords[i].word, lval);
        if(!r)
            return keywords[i].token;

        if(r > 0)
            min = i+1;
        else
            max = i-1;
    }

    return 0;
}
Пример #13
0
int jdfits_write_header_string (JDFits_Type *ft, char *name, char *s, char *comment)
{
   char buf[JDFITS_CARD_SIZE + 1];
   char *b, *bmax, *bsave, ch;

   if ((-1 == check_keyword (name))
       || (-1 == check_ascii (s, 0))
       || (-1 == check_ascii (comment, 1)))
     return -1;

   /* Strings must begin with a ' character in column 11 and have a closing one
    * before the end of the card.  Actually the closing one must be at column
    * 20 or beyond.
    */
   sprintf (buf, "%-8s= '", name);
   bsave = b = buf + strlen(buf);
   bmax = buf + JDFITS_CARD_SIZE;

   while (b < bmax)
     {
	ch = *s++;
	if (ch == 0)
	  {
	     /* Now pad it with blanks */
	     bmax = bsave + 8;
	     while (b < bmax) *b++ = ' ';
	     *b = '\'';
	     *(b + 1) = 0;
	     jdfits_append_comment (buf, comment);
	     return jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE);
	  }

	if (ch == '\'')
	  {
	     *b++ = ch;
	     if (b == bmax) break;
	  }
	*b++ = ch;
     }
   jdfits_error ("String is too long for keyword %s", name);
   return -1;
}
Пример #14
0
void serial_test_task()
{
	char put_ch[2]={'0','\0'};
	char hint[] =  USER_NAME "@" USER_NAME "-STM32:~$ ";
	int hint_length = sizeof(hint);
	char *p = NULL;
	int cmd_count = 0;

	fdout = mq_open("/tmp/mqueue/out", 0);
	fdin = open("/dev/tty0/in", 0);

	for (;; cur_his = (cur_his + 1) % HISTORY_COUNT) {
		p = cmd[cur_his];
		write(fdout, hint, hint_length);

		while (1) {
			read(fdin, put_ch, 1);

			if (put_ch[0] == '\r' || put_ch[0] == '\n') {
				*p = '\0';
				write(fdout, next_line, 3);
				break;
			}
			else if (put_ch[0] == 127 || put_ch[0] == '\b') {
				if (p > cmd[cur_his]) {
					p--;
					write(fdout, "\b \b", 4);
				}
			}
			else if (p - cmd[cur_his] < CMDBUF_SIZE - 1) {
				*p++ = put_ch[0];
				write(fdout, put_ch, 2);
			}
		}
		check_keyword();	
	}
}
Пример #15
0
int check_keyword(char loglist[HISTORY_LIMIT][MAX_LINE],char *args[ARGNUM],int *history_mode,int *next_replace_index,int *history_count,char *input,int *runbkg,char *input_buffer){
	int i;
	i=0;
	while(args[i]!=NULL){
		if(strcmp(args[i],"exit")==0){
				return 1;
			}

			if(strcmp(args[0],"history")==0){
				*history_mode=1;
				printf("history detected\n");
				show_history_proper(loglist,next_replace_index,history_count);
			}

			if(strcmp(args[0],"!!")==0){
//				*history_mode=1;
				// get input value of previous, ptrtok that again, search for keywords again, then fork & execute
				get_prev_cmd(loglist,next_replace_index,input);
				strcpy(input_buffer,input);
				strip_input(input,args);	
				check_keyword(loglist,args,history_mode,next_replace_index,history_count,input,runbkg,input_buffer);
				

			}

			if(strcmp(args[i],"&")==0){	// if & is included, run it in background
				args[i]=NULL;
				*runbkg=1;
			}
		
			i++;

	}

	return 0;
}
Пример #16
0
int main(void){
	char *args[ARGNUM];
	int should_run=1;
	char input[MAX_LINE];
	char input_buffer[MAX_LINE];
	int i,j;
	int runbkg;


	int history_mode=0;
	int next_replace_index=0;
	int history_count=0;
	char loglist[HISTORY_LIMIT][MAX_LINE];

	for(i=0;i<HISTORY_LIMIT;i++){	// reseting loglist
		sprintf(loglist[i],"");
	}


	while(should_run){
		runbkg=0;
		
		// reset args array
		for(i=0;i<ARGNUM;i++){
			args[i]=NULL;
		}
		
		printf("osh>");
		//fflush(stdout);	
		fgets(input,MAX_LINE,stdin);	// get input. enter(\n) value will be included.


		// removing last newline and replace it with null
		for(i=0;i<ARGNUM;i++){
			if(input[i]=='\n'){
				input[i]='\0';
				break;
			}
		}

		strcpy(input_buffer,input);	// make copy of input for later use with history

		//save input in history log
//		update_history(input,loglist,&next_replace_index,&history_count);
//		printf("next_replace_index: %d, history_count: %d\n",next_replace_index,history_count);
//		show_history(loglist);
//
//
		printf("before input: %s\n",input);
		strip_input(input,args);	
		printf("split complete\n");

		if(check_keyword(loglist,args,&history_mode,&next_replace_index,&history_count,input,&runbkg,input_buffer)){
			return 0;
		}

		
		printf("input buffer: %s\n",input_buffer);	
	

		if(history_mode==1){	// used just for skipping remainder
			history_mode=0;
			continue;	// skip the executing part below since history command is not a proper command
		}

			// history mode will not increment next_replace_index, history_count.


		update_history(input_buffer,loglist,&next_replace_index,&history_count);
//		printf("next_replace_index: %d, history_count: %d\n",next_replace_index,history_count);
//		show_history(loglist);


	i=0;
//	printf("args listing with null ending\n");
//	while(args[i]!=NULL){	// print all args values
//		printf("%d %s\n",i,args[i]);
//		i++;
//	}
//
	pid_t pid;
	pid=fork();		// forking
	if(pid<0){
		printf("error\n");
	}
	else if(pid==0){ //child process
//		printf("child-args: %s\n",args[0]);
		execvp(args[0],args);
		return 0;
	}
	else{	// parent process
//		printf("runbkg: %d\n",runbkg);
//		printf("child pid:%d \n",pid);
		int status;
		if(runbkg==0){	
			waitpid(pid,&status,0);
//			printf("wait executed\n");
		}

	}


	} // end of should run

	return 0;
}
Пример #17
0
uint8_t comentario_parser(uint8_t * cadena, uint16_t index, uint8_t token_t)
{
    index++;
    uint16_t len = strlen(cadena);
    uint8_t temp[len+1];
    memset(temp, 0, sizeof(temp));

    uint16_t i=0;
    uint16_t indice = 0;
    uint8_t chars = 0;
    uint8_t espacios = 0;
    for(i=index;i<len;i++)
    {
        if(isspace(cadena[i]))
        {
            if(chars == 1 && espacios == 0)
                espacios++;
		}
        else if(!isalpha(cadena[i]) && !isdigit(cadena[i]) && cadena[i] != '_')
        {
            debug("\nError en linea %d: el compilador encontro un intento de definir una variable en un comentario. Sin embargo, el valor %c no es permitido\n", linea,cadena[i]);
            return 0;
        }
        else
        {
            if(chars == 0 && espacios == 0)
                chars++;
            else if(espacios == 1)
            {
                debug("\nError en linea %d: el compilador encontro un intento de definir una variable en un comentario. Sin embargo, el nombre de la variable no debe contener espacios\n", linea);
                return 0;
            }
            temp[indice++] = cadena[i];
        }
    }

    if(!check_keyword(temp))
        return 0;
    else if(indice == 0)
    {
        debug("\nError en linea %d: debes ingresar el nombre de una variable\n", linea);
        return 0;
    }

	uint8_t token = ht_get(temp);
	if(token != 0)
	{
		if(token == NUMERO && token_t == CHAR)
			debug("\nError en linea %d: la variable \"%s\" ya fue declarada como entero. Por lo tanto, no puedes declarla como \"char\"\n",linea,temp);
		else if((token == CADENA || token == FLOAT) && token_t == CHAR)
			debug("\nError en linea %d: la variable \"%s\" ya fue declarada. No puedes redefinirla como \"char\"\n",linea,temp);
		else if(token == NUMERO && token_t == FLOAT)
			debug("\nError en linea %d: la variable \"%s\" ya fue declarada como entero. Por lo tanto, no puedes redefinirla como \"float\"",linea,temp);
		else if(token == FLOAT && token_t == FLOAT)
			debug("\nError en linea %d: la variable \"%s\" ya fue declarada. No puedes redefinirla como \"float\"\n",linea,temp);
		return 0;
	}
    else if(token == 0)
    {
        if(var_get(temp) != 0)
            debug("\nAviso en la linea %d: has repetido la misma declaracion, por lo cual se ha omitido. No causa conflictos, pero se recomienda que se elimine\n", linea);
        else
        {
            uint8_t id = var_put(temp, token_t);
            if(id == 0 || id == 2)
                return 0;
        }
    }

    return 1;
}
Пример #18
0
int
main(int argc, char **argv)
{
  char ruby_code[1024] = { 0 };
  char last_code_line[1024] = { 0 };
#ifndef ENABLE_READLINE
  int last_char;
  int char_index;
#else
  char *home = NULL;
#endif
  mrbc_context *cxt;
  struct mrb_parser_state *parser;
  mrb_state *mrb;
  mrb_value result;
  struct _args args;
  int n;
  mrb_bool code_block_open = FALSE;
  int ai;
  unsigned int stack_keep = 0;

  /* new interpreter instance */
  mrb = mrb_open();
  if (mrb == NULL) {
    fputs("Invalid mrb interpreter, exiting mirb\n", stderr);
    return EXIT_FAILURE;
  }
  mrb_define_global_const(mrb, "ARGV", mrb_ary_new_capa(mrb, 0));

  n = parse_args(mrb, argc, argv, &args);
  if (n == EXIT_FAILURE) {
    cleanup(mrb, &args);
    usage(argv[0]);
    return n;
  }

  print_hint();

  cxt = mrbc_context_new(mrb);
  cxt->capture_errors = 1;
  cxt->lineno = 1;
  mrbc_filename(mrb, cxt, "(mirb)");
  if (args.verbose) cxt->dump_result = 1;

  ai = mrb_gc_arena_save(mrb);

#ifdef ENABLE_READLINE
  MIRB_USING_HISTORY();
  home = getenv("HOME");
#ifdef _WIN32
  if (!home)
    home = getenv("USERPROFILE");
#endif
  if (home) {
    strcpy(history_path, home);
    strcat(history_path, "/");
    strcat(history_path, history_file_name);
    MIRB_READ_HISTORY(history_path);
  }
#endif


  while (TRUE) {
#ifndef ENABLE_READLINE
    print_cmdline(code_block_open);

    char_index = 0;
    while ((last_char = getchar()) != '\n') {
      if (last_char == EOF) break;
      if (char_index > sizeof(last_code_line)-2) {
        fputs("input string too long\n", stderr);
        continue;
      }
      last_code_line[char_index++] = last_char;
    }
    if (last_char == EOF) {
      fputs("\n", stdout);
      break;
    }

    last_code_line[char_index++] = '\n';
    last_code_line[char_index] = '\0';
#else
    char* line = MIRB_READLINE(code_block_open ? "* " : "> ");
    if (line == NULL) {
      printf("\n");
      break;
    }
    if (strlen(line) > sizeof(last_code_line)-2) {
      fputs("input string too long\n", stderr);
      continue;
    }
    strcpy(last_code_line, line);
    strcat(last_code_line, "\n");
    MIRB_ADD_HISTORY(line);
    free(line);
#endif

    if (code_block_open) {
      if (strlen(ruby_code)+strlen(last_code_line) > sizeof(ruby_code)-1) {
        fputs("concatenated input string too long\n", stderr);
        continue;
      }
      strcat(ruby_code, last_code_line);
    }
    else {
      if (check_keyword(last_code_line, "quit") || check_keyword(last_code_line, "exit")) {
        break;
      }
      strcpy(ruby_code, last_code_line);
    }

    /* parse code */
    parser = mrb_parser_new(mrb);
    parser->s = ruby_code;
    parser->send = ruby_code + strlen(ruby_code);
    parser->lineno = cxt->lineno;
    mrb_parser_parse(parser, cxt);
    code_block_open = is_code_block_open(parser);

    if (code_block_open) {
      /* no evaluation of code */
    }
    else {
      if (0 < parser->nerr) {
        /* syntax error */
        printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
      }
      else {
        /* generate bytecode */
        struct RProc *proc = mrb_generate_code(mrb, parser);

        if (args.verbose) {
          mrb_codedump_all(mrb, proc);
        }
        /* pass a proc for evaulation */
        /* evaluate the bytecode */
        result = mrb_context_run(mrb,
            proc,
            mrb_top_self(mrb),
            stack_keep);
        stack_keep = proc->body.irep->nlocals;
        /* did an exception occur? */
        if (mrb->exc) {
          p(mrb, mrb_obj_value(mrb->exc), 0);
          mrb->exc = 0;
        }
        else {
          /* no */
          if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
            result = mrb_any_to_s(mrb,result);
          }
          p(mrb, result, 1);
        }
      }
      ruby_code[0] = '\0';
      last_code_line[0] = '\0';
      mrb_gc_arena_restore(mrb, ai);
    }
    mrb_parser_free(parser);
    cxt->lineno++;
  }
  mrbc_context_free(mrb, cxt);
  mrb_close(mrb);

#ifdef ENABLE_READLINE
  MIRB_WRITE_HISTORY(history_path);
#endif

  return 0;
}
Пример #19
0
int
push_val(int type)
{
	unsigned int mul, val;
	int op;
	char c;

	val = 0;
	c = *expr;

	switch (type) {
	/* program counter */
	case T_PC:
		if (data_loccnt == -1)
			val = (loccnt + (page << 13));
		else
			val = (data_loccnt + (page << 13));
		expr++;
		break;

	/* char ascii value */
	case T_CHAR:
		expr++;
		val = *expr++;
		if ((*expr != c) || (val == 0)) {
			error("Syntax Error!");
			return (0);
		}
		expr++;
		break;

	/* symbol */
	case T_SYMBOL:
		/* extract it */
		if (!getsym())
			return (0);

		/* an user function? */
		if (func_look()) {
			if (!func_getargs())
				return (0);

			expr_stack[func_idx++] = expr;
			expr = func_ptr->line;
			return (1);
		}

		/* a predefined function? */
		op = check_keyword();
		if (op) {
			if (!push_op(op))
				return (0);
			else
				return (1);
		}

		/* search the symbol */
		expr_lablptr = stlook(1);

		/* check if undefined, if not get its value */
		if (expr_lablptr == NULL)
			return (0);
		else if (expr_lablptr->type == UNDEF)
			undef++;
		else if (expr_lablptr->type == IFUNDEF)
			undef++;
		else
			val = expr_lablptr->value;

		/* remember we have seen a symbol in the expression */
		expr_lablcnt++;
		break;

	/* binary number %1100_0011 */
	case T_BINARY:
		mul = 2;
		goto extract;

	/* hexa number $15AF */
	case T_HEXA:
		mul = 16;
		goto extract;

	/* decimal number 48 (or hexa 0x5F) */
	case T_DECIMAL:
		if ((c == '0') && (toupper(expr[1]) == 'X')) {
			mul = 16;
			expr++;
		}
		else {
			mul = 10;
			val = c - '0';
		}
		/* extract a number */
extract:
		for (;;) {
			expr++;
			c = *expr;

			if (isdigit(c))
				c -= '0';
			else if (isalpha(c)) {
				c = toupper(c);
				if (c < 'A' && c > 'F')
					break;
				else {
					c -= 'A';
					c += 10;
				}
			}
			else if (c == '_' && mul == 2)
				continue;
			else
				break;
			if (c >= mul)
				break;
			val = (val * mul) + c;
		}
		break;
	}

	/* check for too big expression */
	if (val_idx == 63) {
		error("Expression too complex!");
		return (0);
	}

	/* push the result on the value stack */
	val_idx++;
	val_stack[val_idx] = val;

	/* next must be an operator */
	need_operator = 1;

	/* ok */
	return (1);
}
Пример #20
0
static int cc_token(parser_ctx_t *ctx, void *lval)
{
    unsigned id_len = 0;
    cc_var_t *var;

    static const WCHAR cc_onW[] = {'c','c','_','o','n',0};
    static const WCHAR setW[] = {'s','e','t',0};

    ctx->ptr++;

    if(!check_keyword(ctx, cc_onW, NULL))
        return init_cc(ctx) ? 0 : -1;

    if(!check_keyword(ctx, setW, NULL)) {
        const WCHAR *ident;
        unsigned ident_len;
        cc_var_t *var;

        if(!init_cc(ctx))
            return -1;

        if(!skip_spaces(ctx))
            return lex_error(ctx, JS_E_EXPECTED_AT);

        if(!parse_cc_identifier(ctx, &ident, &ident_len))
            return -1;

        if(!skip_spaces(ctx) || *ctx->ptr != '=')
            return lex_error(ctx, JS_E_EXPECTED_ASSIGN);
        ctx->ptr++;

        if(!parse_cc_expr(ctx)) {
            WARN("parsing CC expression failed\n");
            return -1;
        }

        var = find_cc_var(ctx->script->cc, ident, ident_len);
        if(var) {
            var->val = ctx->ccval;
        }else {
            if(!new_cc_var(ctx->script->cc, ident, ident_len, ctx->ccval))
                return lex_error(ctx, E_OUTOFMEMORY);
        }

        return 0;
    }

    if(!check_keyword(ctx, ifW, NULL)) {
        if(!init_cc(ctx))
            return -1;

        if(!skip_spaces(ctx) || *ctx->ptr != '(')
            return lex_error(ctx, JS_E_MISSING_LBRACKET);

        if(!parse_cc_expr(ctx))
            return -1;

        if(get_ccbool(ctx->ccval)) {
            /* continue parsing block inside if */
            ctx->cc_if_depth++;
            return 0;
        }

        return skip_code(ctx, TRUE);
    }

    if(!check_keyword(ctx, elifW, NULL) || !check_keyword(ctx, elseW, NULL)) {
        if(!ctx->cc_if_depth)
            return lex_error(ctx, JS_E_SYNTAX);

        return skip_code(ctx, FALSE);
    }

    if(!check_keyword(ctx, endW, NULL)) {
        if(!ctx->cc_if_depth)
            return lex_error(ctx, JS_E_SYNTAX);

        ctx->cc_if_depth--;
        return 0;
    }

    if(!ctx->script->cc)
        return lex_error(ctx, JS_E_DISABLED_CC);

    while(ctx->ptr+id_len < ctx->end && is_identifier_char(ctx->ptr[id_len]))
        id_len++;
    if(!id_len)
        return '@';

    TRACE("var %s\n", debugstr_wn(ctx->ptr, id_len));

    var = find_cc_var(ctx->script->cc, ctx->ptr, id_len);
    ctx->ptr += id_len;
    if(!var || var->val.is_num) {
        *(literal_t**)lval = new_double_literal(ctx, var ? var->val.u.n : NAN);
        return tNumericLiteral;
    }

    *(literal_t**)lval = new_boolean_literal(ctx, var->val.u.b);
    return tBooleanLiteral;
}
Пример #21
0
int jdfits_write_header_comment (JDFits_Type *ft, char *name, char *comment)
{
   char buf[JDFITS_CARD_SIZE + 1];
   char *bmin, *bmax, *b, ch;

   if (name == NULL) name = "";

   /* Check for all blanks which is ok for comments */
   b = name;
   while (((ch = *b++) != 0) && (ch == ' '))
     ;

   if (ch == 0)
     {
	if (strlen (name) > 8)
	  {
	     jdfits_error ("A keyword must be less than 9 characters long.");
	     return -1;
	  }
     }
   else if (-1 == check_keyword (name))
     return -1;

   if (comment == NULL) comment = "";

   if (-1 == check_ascii (comment, 1)) return -1;

   sprintf (buf, "%-8s ", name);
   bmin = buf + 9;
   bmax = buf + JDFITS_CARD_SIZE;

   while (1)
     {
	b = bmin;
	while (((ch = *comment) != 0) && (b < bmax))
	  {
	     comment++;
	     if (ch == '\n') break;
	     *b++ = ch;
	  }

	if ((b == bmax) && (ch != 0))
	  {
	     char *bmin_2;
	     unsigned int diff;

	     diff = bmax - bmin;
	     bmin_2 = bmin + (diff / 2);
	     /* Try to break it at a space. */
	     b--;
	     while ((b > bmin_2) && (*b != ' ')) b--;
	     if (b > bmin_2)
	       {
		  comment -= (bmax - b);
		  comment++; /* +1 to avoid the space */
		  ch = ' ';
	       }
	     else
	       {
		  comment--;
		  b = bmax;
		  *(b - 1) = '\\';
	       }
	  }

	while (b < bmax) *b++ = ' ';

	*b = 0;

	if (-1 == jdfits_write (ft, (unsigned char *) buf, JDFITS_CARD_SIZE))
	  return -1;

	if ((ch == '\n') && (*comment == 0)) break;
	if (ch == 0) break;
     }
   return 0;
}
Пример #22
0
/* Funkcia spusti konecny automat na spracovanie lexemu */
 tToken get_Token(){
 	tState state = sStart;
 	int i = 0;		// pocitadlo nacitanych znakov
 	int c;			// prave nacitany znak
 	int escap;		//pomocna premenna na urcenie escape sekvencii
 	int escap2;		// -||-
 	bool cont = true;
 	char hexa[3];		//spracovanie hexadecimalneho cisla.
/* inicializacia tokenu */
 	token.id = sStart;
 	init_string(&i);

/* Cyklus while ktory reprezentuje DKA */
 	while((c = getc(file)) && (cont)){
 		switch(state){
 			case sStart:{
 				if((isalpha(c)) || (c == '_'))				state = sIdent;
 				else if((c > '0') && (c <= '9'))			state = sInteger;
 				else if(c == '=')							state = sAssign;
 				else if(c == '/')							state = sDivide;
 				else if(c == '!')							state = sExclam;
 				else if(c == '>')							state = sGreater;
 				else if(c == '<')							state = sLess;
 				else if(c == ';')							state = sSemicolon;
 				else if(c == '(')							state = sLParenth;
 				else if(c == ')')							state = sRParenth;
 				else if(c == '{')							state = sLSetPar;
 				else if(c == '}')							state = sRSetPar;
 				else if(c == '+')							state = sPlus;
 				else if(c == '-')							state = sMinus;
 				else if(c == '*')							state = sMult;
 				else if(c == ',')							state = sComma;
 				else if(c == EOF)							state = sEndofFile;
 				
 				else if(c == '"'){						
 					state = sString;
 					break;
 				} 	

 				else if(c == '0'){
 					state = sNull;
 					break;
 				}

 				//Ak sa jedna o biely znak
 				else if(isspace(c)){
 					state = sStart;
 					break;
 				}
 				//Nejedna sa o lexem jazyka IFJ15
 				else{
 					state = sError;
 					break;
 				}

 				//rozsir token o prve nacitany znak
 				expand_token(c, &i);
 				break;
 			}

 			//prvy nacitany znak bol 0
 			case sNull:{		
 				if(c == '0'){
 					state = sNull;
 				} else if((c > '0') && (c <= '9')){
 					state = sInteger;
 					expand_token(c, &i);	//rozsirime token o jeden znak
 				} else if(c == '.'){ 
 					state = sIsDouble;
 					expand_token('0', &i);
 					expand_token(c, &i);
 				} else{
					state = sInteger;
					expand_token('0', &i);
 					fill_token(state);		//prepiseme id tokenu
 					state = sEnd;
 					undo_c(c);		//posledny nacitany znak vratime spat
 				}
 				break;
 			}

 			//prvy nacitany znak bol '_' alebo pismeno
 			case sIdent:{
 				if((isdigit(c)) || (isalpha(c)) || c == '_'){
 					state = sIdent;
 					expand_token(c, &i);
 				} else{
 					/* 
 					*  kedze sa jedna o identifikator, musime sa
 					*  uistit, ci nejde o klucove alebo o rezervovane slovo
 					*/
 					token.id = check_keyword(token.attribute);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//Prvy nacitany znak bol numericky.
 			case sInteger:{
 				if(isdigit(c)){
 					state = sInteger;
 					expand_token(c, &i);
 				} else if(c == '.'){		//desatinne cislo
 					state = sIsDouble;
 					expand_token(c, &i);
 				} else if((c == 'e') || (c == 'E')){	//cele cislo s exp.
 					state = sIsExpo;
 					expand_token(c, &i);
 				} else{
 					//Nacitali sme ine ako cislo, posielame token int.
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//skontrolujem ci po desatinnej bodke nasleduje cislo
 			case sIsDouble:{
 				if(isdigit(c)){
 					state = sDouble;
 					expand_token(c, &i);
 				} else {
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			//desatinne cislo
 			case sDouble:{
 				if(isdigit(c)){
 					state = sDouble;
 					expand_token(c, &i);
 				} else if((c == 'e') || (c == 'E')){
 					//desatinne cislo s exponentom
 					state = sIsExpo;
 					expand_token(c, &i);
 				} else{
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			/* skontrolujeme ci je zadane znamienko pre exponent
 			*  alebo hned nasleduje cislo, v opacnom pripade sa jedna
 			*  o chybu. */
 			case sIsExpo:{
 				if((c == '+') || (c == '-')){
 					state = sIsExpo2;
 					expand_token(c, &i);
 				} else if(isdigit(c)){
 					state = sExpo;
 					expand_token(c, &i);
 				} else{
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			//skontrolujeme ci po znamienku je cislo
 			case sIsExpo2:{
 				if(isdigit(c)){
 					state = sExpo;
 					expand_token(c, &i);
 				} else{
 					//Chyba, po znamienku nasleduje iny znak ako cislo.
 					state = sError;
 					undo_c(c);
 				}
 			}

 			//nacitavanie cislic pre exponent.
 			case sExpo:{
 				if(isdigit(c)){
 					state = sExpo;
 					expand_token(c, &i);
 				} else{
 					state = sDouble;
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//Ak bola nacitana uvodzovka, jedna sa o retazec.
 			case sString:{
 				if(c == '"'){
 					fill_token(state);
 					state = sEnd;
 				} else if((c == '\n') || (c == EOF)){
 					state = sError;
 				} else if(c == 92){
 					state = sEscSeq;
 				} else{
 					expand_token(c, &i);
 					state = sString;
 				}
 				break;
 			}

 			//Escape sekvencia v retazci.
 			case sEscSeq:{
 				if(c == '"'){
 					state = sString;
 					expand_token(c, &i);
 				} else if(c == 'n'){
 					escap = '\n';
 					state = sString;
 					expand_token(escap, &i);
 				} else if(c == 't'){
 					escap = '\t';
 					state = sString;
 					expand_token(escap, &i);
 				} else if(c == 92){
 					state = sString;
 					expand_token(c, &i);
 				} else if(c == 'x'){
 					escap = 'x';
 					state = sEscHex;
 				} else{
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			/* 
 			* Zadavanie znakov pomocou escape
 			* sekvencie vramci retazcoveho literalu
 			*/
 			case sEscHex:{
 				if(isxdigit(c)){
 					state = sEscHex2;
 					escap2 = c;
 					hexa[0] = (char)c;
 				} else{
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			/*
 			* Pokracovanie hex. v escape sekvecii
 			*/
 			case sEscHex2:{
 				if(isxdigit(c)){
 					state = sString;
 					hexa[1] = (char)c;
 					hexa[2] = '\0';
 					escap2 = HextoDec(hexa);
 					if(escap2 == 0){
 						state = sError;
 					} else{
 						expand_token(escap2, &i);
 					}
 				} else{
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			//prvy znak bol '='
 			case sAssign:{
 				if(c == '='){
 					state = sEqual;
 					expand_token(c, &i);
 				} else{
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//prvy znak bol '/'
 			case sDivide:{
 				if(c == '/'){
 					state = sLComment;
 				} else if(c == '*'){
 					state = sBComment;
 				} else{
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//jedna sa o riadkovy komentar
 			case sLComment:{
 				if(c == '\n'){
 					state = sStart;
 					i = 0;
 				} else if (c == EOF){
 					state = sEndofFile;
 				} else{
 					state = sLComment;
 				}
 				break;
 			}

 			//Blokovy komenta /*
 			case sBComment:{
 				if(c == '*'){
 					state = sBlockEnd;
 				} else if(c == EOF){
 					state = sError;
 				} else{
 					state = sBComment;
 				}
 				break;
 			}

 			//Zisti ci sa blokovy komentar spravny dokoncil
 			case sBlockEnd:{
 				if(c == '/'){
 					state = sStart;
 					i = 0;
 				} else if(c == EOF){
 					state = sError;
 				} else{
 					state = sBComment;
 				}
 				break;
 			}

 			//prvy nacitany znak bol !
 			case sExclam:{
 				if(c == '='){
 					state = sNotEq;
 					expand_token(c, &i);
 				} else{
 					// ! samotny nie je lexem jazyka IFJ15
 					state = sError;
 					undo_c(c);
 				}
 				break;
 			}

 			// prvy nacitany znak je >
 			case sGreater:{
 				if(c == '='){ // >=
 					state = sGrorEq;
 					expand_token(c, &i);
 				} else if(c == '>'){ // >>
 					state = sCin;
 					expand_token(c, &i);
 				} else{ // >>
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			//Prvy nacitany znak bol <
 			case sLess:{
 				if(c == '='){ //<=
 					state = sLeorEq;
 					expand_token(c, &i);
 				} else if(c == '<'){ // <<
 					state = sCout;
 					expand_token(c, &i);
 				} else{ // <
 					fill_token(state);
 					state = sEnd;
 					undo_c(c);
 				}
 				break;
 			}

 			case sEqual:		// ==
 			case sNotEq:		// !=
 			case sGrorEq:		// >=
 			case sLeorEq:		// <=
 			case sSemicolon:	// ;
 			case sLParenth:		// (
 			case sRParenth:		// )
 			case sLSetPar:		// {
 			case sRSetPar:		// }
 			case sPlus:			// +
 			case sMinus:		// -
 			case sMult:			// *
 			case sEndofFile:	// EOF
 			case sComma:		// ,
 			case sCout:			// <<
 			case sCin:			// >>
 			case sKeyWord:
 			case sResWord:{
 				fill_token(state);
 				state = sEnd;
 				undo_c(c);
 				break;
 			}

 			//Nastala lexikalna chyba
 			case sError:{
 				scaner_error = LEX_ERR;
 				fill_token(state);
 				cont = false;
 				break;
 			}

 			//Koncovy stav DKA
 			case sEnd:{
				undo_c(c);
				undo_c(c);
 				cont = false;
 				break;
 			}
 		}

 		//Nastala lexikalna chyba
 		if(scaner_error){
 			break;
 		}

 		/* Ak bol precitany znak noveho riadku
 		*  inkrementujeme pocitadlo riadkov. */
 		if(c == '\n'){
 			row++;
 		}
 	}

 	PomUk = token.attribute;
 /* Vratime token parseru */
 	return token;
 }
Пример #23
0
//hlavni funkce
struct lexeme read_lexeme(void) {
	struct lexeme tmpData;
	tmpData.type = NO_TYPE;

	read_input();

q0: //default state
	if(PRINT) printf("q0 default\n");
	switch(input_char_type) {
		case UNDERSCORE:
		case LETTER:
			temp_length = 0;
			save_temp(input_char);
			read_input();
			goto q1; //identifier
		case DIGIT:
			tmpData.type = INTEGER;
			temp_length = 0;
			save_temp(input_char);
			read_input();
			goto q4; //integer or double
			break;
		case WHITE_SPACE:
			read_input();
			goto q0; //default state
		/*
		case UNDERSCORE:
			temp_length = 0;
			save_temp(input_char);
			read_input();
			goto q1; //underscored identifier
		*/
		case END:
			tmpData.type = END_OF_FILE;
			return tmpData;
		case OTHERS:
			switch(input_char) {
				case '+':
					tmpData.type = PLUS;
					return tmpData;
				case '-':
					tmpData.type = MINUS;
					return tmpData;
				case '*':
					tmpData.type = MULT;
					return tmpData;
				case '/':
					read_input();
					goto q3; //comments or divide
				case '=':
					read_input();
					if(input_char == '=') {
						tmpData.type = EQ;
						return tmpData;
					}
					return_input();
					tmpData.type = EQUALS;
					return tmpData;
				case '<':
					read_input();
					if(input_char == '=') {
						tmpData.type = LTE;
						return tmpData;
					} else if(input_char == '<') {
						tmpData.type = INSOP;
						return tmpData;
					}
					return_input();
					tmpData.type = LT;
					return tmpData;
				case '>':
					read_input();
					if(input_char == '=') {
						tmpData.type = GTE;
						return tmpData;
					} else if(input_char == '>') {
						tmpData.type = EXTOP;
						return tmpData;
					}
					return_input();
					tmpData.type = GT;
					return tmpData;
				case '!':
					read_input();
					if(input_char == '=') {
						tmpData.type = NEQ;
						return tmpData;
					}
					throw_error(CODE_ERROR_LEX, "invalid input");
					break;
				case ';':
					tmpData.type = SEMICOLON;
					return tmpData;
				case '(':
					tmpData.type = LPAR;
					return tmpData;
				case ')':
					tmpData.type = RPAR;
					return tmpData;
				case '{':
					tmpData.type = LBR;
					return tmpData;
				case '}':
					tmpData.type = RBR;
					return tmpData;
				case ',':
					tmpData.type = COLON;
					return tmpData;
				case '"':
					tmpData.type = STRING;
					temp_length = 0;
					chunks = 0;
					length = 0;
					read_input();
					goto q8; //string
				default:
					throw_error(CODE_ERROR_LEX, "invalid input");
					break;
			}
			break;
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
	}

q1: //identifier OK
	if(PRINT) printf("q1 identifier\n");
	switch(input_char_type) {
		case LETTER:
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q1; //identifier
		case UNDERSCORE:
			save_temp(input_char);
			read_input();
			goto q1; //underscored identifier
		default:
			return_input();
			save_temp(0);
			if((tmpData.type = check_keyword(temp)) == IDENTIFIER) {
				if((tmpData.value.string = (char *)malloc(temp_length)) == NULL)
					throw_error(CODE_ERROR_INTERNAL, "malloc error");
				memcpy((void *)tmpData.value.string, (void *)temp, temp_length);
			}
			return tmpData;
	}
/*
q2: //underscored identifier OK
	if(PRINT) printf("q2 underscored identifier\n");
	switch(input_char_type) {
		case LETTER:
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q1; //identifier
		case UNDERSCORE:
			save_temp(input_char);
			read_input();
			goto q2; //underscored identifier
		default:
			return_input();
			return tmpData;
	}
*/
q3: //comments or divide OK
	if(PRINT) printf("q3 comments or divide\n");
	switch(input_char_type) {
		case LETTER:
		case DIGIT:
		case WHITE_SPACE:
			return_input();
			tmpData.type = DIVIDE;
			return tmpData;
		default:
			switch(input_char) {
				case '/':
					//q11
					do {
						read_input();
					} while(input_char != '\n' && input_char_type != END);
					if(input_char_type == END) {
						tmpData.type = END_OF_FILE;
						return tmpData;
					}
					read_input();
					goto q0; //default state
				case '*':
					//q12
					do {
						do {
							read_input();
						} while(input_char != '*' && input_char_type != END);
						if(input_char_type == END) {
							throw_error(CODE_ERROR_LEX, "invalid input");
							break;
						}
						read_input();
						if(input_char == '/') {
							read_input();
							goto q0; //default state
						} else if(input_char == '*') {
							return_input();
						} else if(input_char_type == END) {
							throw_error(CODE_ERROR_LEX, "invalid input");
							break;
						}
					} while(1);
				default:
					return_input();
					tmpData.type = DIVIDE;
					return tmpData;
			}
			break;
	}

q4: //integer or double OK
	if(PRINT) printf("q4 integer or double\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q4; //integer or double
		/*
		case WHITE_SPACE:
			save_temp(0);
			tmpData.value.integer = atoi((const char *)temp);
			return tmpData;
		*/
		case LETTER:
			if(input_char == 'e' || input_char == 'E') {
				save_temp(input_char);
				read_input();
				tmpData.type = DOUBLE;
				goto q5; //double e
			} else {
				throw_error(CODE_ERROR_LEX, "invalid input");
				break;
			}
		case END:
			/*
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
			*/
			return_input();
			save_temp(0);
			tmpData.value.integer = atoi((const char *)temp);
			return tmpData;			
		case UNDERSCORE:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;				
		case OTHERS:			
			if(input_char == '.') {
				save_temp(input_char);
				read_input();
				tmpData.type = DOUBLE;
				goto q13; //double
			}
			return_input();
			save_temp(0);
			tmpData.value.integer = atoi((const char *)temp);
			return tmpData;		
		default:
			return_input();
			save_temp(0);
			tmpData.value.integer = atoi((const char *)temp);
			return tmpData;
	}

q5: //double e OK
	if(PRINT) printf("q5 double e\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q7; //double e
		case OTHERS:
			if(input_char == '+' || input_char == '-') {  
				save_temp(input_char);
				read_input();
				goto q14; //double e +-
			}/* else {
				return_input();
				save_temp(0);
				tmpData.value.real = strtod((const char *)temp, &e_strtod);
				return tmpData;
			}*/	
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
	}

q13: //potential double
	if(PRINT) printf("q13 potential double\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q6; //double
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;				
	} 
	
q14: //potential double e +-
	if(PRINT) printf("q14 potential double e +-\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q7; //double e +-
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;				
	} 	

q6: //double OK
	if(PRINT) printf("q6 double\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q6; //double
		case LETTER:
			if(input_char == 'e' || input_char == 'E') {
				save_temp(input_char);
				read_input();
				goto q5; //double e
			} else {
				throw_error(CODE_ERROR_LEX, "invalid input");
				break;
			}
		/*
		case WHITE_SPACE:
			save_temp(0);
			tmpData.value.real = strtod((const char *)temp, &e_strtod);
			return tmpData;
		case END:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
		*/ 
		default:
			return_input();
			save_temp(0);
			tmpData.value.real = strtod((const char *)temp, &e_strtod);
			return tmpData;
	}

q7: //double e +- OK
	if(PRINT) printf("q7 double e +-\n");
	switch(input_char_type) {
		case DIGIT:
			save_temp(input_char);
			read_input();
			goto q7; //double e +-
		/*
		case WHITE_SPACE:
			save_temp(0);
			tmpData.value.real = strtod((const char *)temp, &e_strtod);
			return tmpData;
		case END:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
		*/
		default:
			return_input();
			save_temp(0);
			tmpData.value.real = strtod((const char *)temp, &e_strtod);
			return tmpData;
	}

q8: //string OK
	if(PRINT) printf("q8 string\n");
	switch(input_char_type) {
		case OTHERS:	
		 		if(input_char == '\\') {
				//save(&tmpData, input_char);
				read_input();
				goto q9;	//escaped string
			} else if(input_char == '"') {
				//q10
				save(&tmpData, 0);  //UZAVRENI RETEZCE NULOVYM ZNAKEM
				return tmpData;
			}
			save(&tmpData, input_char);
			read_input();
			goto q8; //string
		case WHITE_SPACE:	
				if(input_char == 32) {
				save(&tmpData, input_char);
				read_input();
				goto q8; //string	
			}
			printf("%d\n",input_char);	
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
		case END:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;
		default:	
			save(&tmpData, input_char);
			read_input();
			goto q8;  //string
	}

q9: //escaped string OK
	if(PRINT) printf("q9 escaped string\n");
	switch(input_char_type) {
		case END:
		if(PRINT) printf("vypis 1\n");
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;			
		default:
		if(PRINT) printf("vypis 2\n");
		
		//  n -> \n   t -> \t   /* LOMITKA DOPLNENA */
		
			if(input_char == 'n' || input_char == 't' || input_char == '\\' || input_char == '"') 
			{
												if(PRINT) printf("vypis 3\n");
			//	save(&tmpData, '\\');   NENMA TU BYT
 				if(input_char == 'n')
 				save(&tmpData, '\n');	
 				else if (input_char == 't')
 				save(&tmpData, '\t');
 				else
				save(&tmpData, input_char);
												if(PRINT) printf("vypis 5\n");
				read_input();
												if(PRINT) printf("vypis 6\n");
				goto q8;  //string
												if(PRINT) printf("vypis 7\n");
			} else if(input_char == 'x') 
												if(PRINT) printf("vypis 8\n");
			{
				read_input();
												if(PRINT) printf("vypis 9\n");
				goto q16;
			}
			throw_error(CODE_ERROR_LEX, "invalid input");
												if(PRINT) printf("\n");
			break;			
	}
	
	
	
q16: //escaped string x

tmpx = 0;
	switch(input_char_type) {
		case LETTER:
									if(PRINT) printf("vypis 10\n");
			if(input_char >= 'A' && input_char <= 'F') {
								tmpx += (input_char - 'A'+10)*16;
				
												break;
									if(PRINT) printf("vypis 11\n");
								
			} else if(input_char >= 'a' && input_char <= 'f') {
								tmpx += (input_char - 'a'+10)*16;
				
									if(PRINT) printf("vypis 12\n");	
								break;						
					
			}
			throw_error(CODE_ERROR_LEX, "invalid input");
	
						
		case DIGIT:
			tmpx += (input_char - '0')*16;
			//ulozit do tmp promenne ....prevod na cislo dokoncit z hexadec. na cislo
			//neznamekovy char, nasobeni 16
			// tmp_esc_val[0] = '2';  DELETE
 			//printf("** %i\n", tmp_esc_val);
			//printf("** %c\n", tmp_esc_val);			
			//tmp_esc_val = input_char * 16;
					if(PRINT) printf("vypis 14\n");
			
			break;
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;		
	}
	read_input();
	goto q17;
	
q17: //escaped string xH
	switch(input_char_type) {
		case LETTER:
		if(input_char >= 'A' && input_char <= 'F') {
				tmpx += (input_char - 'A'+10);
				break;
									
			} else if(input_char >= 'a' && input_char <= 'f') {
				tmpx += (input_char - 'a'+10);
				break;							
			}
			throw_error(CODE_ERROR_LEX, "invalid input");
			
		case DIGIT:
			tmpx += (input_char - '0');
			break;
			//tmp_esc_val[1] = '1';
			//const char *frmtChar = hexToInt(tmp_esc_val);
			//unsigned char *resChar;
			//sscanf(&frmtChar, "%c", &resChar);
		
		default:
			throw_error(CODE_ERROR_LEX, "invalid input");
			break;		
	}	
	save(&tmpData,tmpx);			
	read_input();
	goto q8;
	}
Пример #24
0
void serial_test_task()
{
	char put_ch[2]={'0','\0'};
	char hint[] =  USER_NAME "@" USER_NAME "-STM32:~$ ";
	int hint_length = sizeof(hint);
	char *p = NULL;
	size_t i = cur_his;

	fdout = mq_open("/tmp/mqueue/out", 0);
	fdin = open("/dev/tty0/in", 0);

	for (;; i = cur_his = (cur_his + 1) % HISTORY_COUNT) {
		p = cmd[cur_his];
		write(fdout, hint, hint_length);

		while (1) {
			read(fdin, put_ch, 1);

			if (put_ch[0] == '\r' || put_ch[0] == '\n') {
				*p = '\0';
				write(fdout, next_line, 3);
				break;
			}
			else if (put_ch[0] == 127 || put_ch[0] == '\b') {
				if (p > cmd[cur_his]) {
					p--;
					write(fdout, "\b \b", 4);
				}
			}
			else if (p - cmd[cur_his] < CMDBUF_SIZE - 1) {
				if(put_ch[0] == '\033'){					//arrow key detection
					read(fdin, put_ch, 1);
					if(put_ch[0] == '['){
						read(fdin, put_ch, 1);
						if(put_ch[0] == 'A' || put_ch[0] == 'B'){		//up/down arrow key
							if(put_ch[0] == 'A'? i : i < cur_his){				//browse history
								while(p > cmd[cur_his]){	//delete current text
									p--;
									write(fdout, "\b \b", 4);
								}
								i += put_ch[0] == 'A'? -1 : 1;
								if(put_ch[0] == 'A' || i != cur_his){
									write(fdout, cmd[i], strlen(cmd[i])+1);
									memcpy(cmd[cur_his],cmd[i], strlen(cmd[i])+1);
									p = cmd[cur_his]+strlen(cmd[i]);
								}else p = cmd[cur_his];
							}
						}else if(put_ch[0] == 'C'){	//right arrow key
						}else if(put_ch[0] == 'D'){	//left arrow key
						}else{
							*p++ = '[';
							*p++ = put_ch[0];
							*p = '\0';
							write(fdout, p-2, 3);
						}
					}else{
						*p++ = put_ch[0];
						write(fdout, put_ch, 2);
					}
				}else{
					*p++ = put_ch[0];
					write(fdout, put_ch, 2);
				}
			}
		}
		check_keyword();
	}
}
Пример #25
0
/** Lexikalni analyzator
 *
 * @param string slozi k navratu identifikatoru a cisel
 * vraci ciselnou reprezentaci tokenu
 */
static inline int get_token__(void)
{
    static int c;
    static int state = FSM_READ;

    int num = 0;

    // buffer se musi vyprazdnit
    str_clean(&str);

    for(;;) {

        switch(state) {
        // nacitani znaku
        case FSM_READ:
            c = fgetc(input);
        // nekdy byva potreba nacteni znaku preskocit
        case FSM_START:
            if(isspace(c)) {
                state = FSM_READ;
                if(c == '\n')
                    ++line;
            }
            else if(isalpha(c) || c == '_')
                state = FSM_IDENTIFIER;
            else if(isdigit(c))
                state = FSM_NUMBER;
            else if(c == '+') {
                state = FSM_READ;
                return PLUS;
            }
            else if(c == '*') {
                state = FSM_READ;
                return MUL;
            }
            else if(c == '/') {
                state = FSM_READ;
                return DIV;
            }
            else if(c == '.')
                state = FSM_DOT;
            else if(c == '<')
                state = FSM_LESS;
            else if(c == '>')
                state = FSM_GREAT;
            else if(c == '~')
                state = FSM_NOT_EQUALS;
            else if(c == '^') {
                state = FSM_READ;
                return POWER;
            }
            else if(c == '(') {
                state = FSM_READ;
                return LBRAC;
            }
            else if(c == ')') {
                state = FSM_READ;
                return RBRAC;
            }
            else if(c == ',') {
                state = FSM_READ;
                return COMMA;
            }
            else if(c == '-')
                state = FSM_DASH;
            else if(c == '=')
                state = FSM_EQUALS;
            else if(c == '"')
                state = FSM_STRING;
            else if(c == ';') {
                state = FSM_READ;
                return SEMICOLON;
            }
            else if(c == EOF)
                return NOTHING;
            else {
                state = FSM_READ;
                return ERROR_LEX_UX_CHAR;
            }
            break;

        case FSM_IDENTIFIER:
            str_push(&str, c);
            c = fgetc(input);
            if(! (isalnum(c) || c == '_')) {
                state = FSM_START;
                return check_keyword(&str); // kontrola klicovych slov
            }
            break;

        case FSM_NUMBER:
            str_push(&str, c);
            c = fgetc(input);
            if(isdigit(c))
                ;
            else if(c == '.')
                state = FSM_FLOAT0;
            else if(c == 'E' || c == 'e')
                state = FSM_EXP_E;
            else {
                state = FSM_START;
                return NUMBER;
            }
            break;

        case FSM_FLOAT0:
            str_push(&str, c);
            c = fgetc(input);
            if(isdigit(c))
                state = FSM_FLOAT;
            else {
                state = FSM_START;
                return ERROR_LEX_NUMBER;
            }
            break;

        case FSM_FLOAT:
            str_push(&str, c);
            c = fgetc(input);
            if(isdigit(c))
                ;
            else if(c == 'E' || c == 'e')
                state = FSM_EXP_E;
            else {
                state = FSM_START;
                return NUMBER;
            }
            break;

        case FSM_EXP_E:
            str_push(&str, c);
            c = fgetc(input);
            if(c == '+' || c == '-')
                state = FSM_EXP0;
            else if (isdigit(c))
                state = FSM_EXP;
            else {
                state = FSM_START;
                return ERROR_LEX_NUMBER;
            }
            break;

        case FSM_EXP0:
            str_push(&str, c);
            c = fgetc(input);
            if(isdigit(c))
                state = FSM_EXP;
            else {
                state = FSM_START;
                return ERROR_LEX_NUMBER;
            }
            break;


        case FSM_EXP:
            str_push(&str, c);
            c = fgetc(input);
            if(! isdigit(c)) {
                state = FSM_START;
                return NUMBER;
            }
            break;

// NOTE: Zminit v dokumentaci, ze jsme zakazali primo vkladat ridici znaky ASCII do retezcu

        case FSM_STRING:
            c = fgetc(input);
            if(c < ASCII_CONTROLL) {
                state = FSM_START;
                return ERROR_LEX_UX_CHAR;
            } else if(c == '\\')
                state = FSM_ESCAPE;
            else if(c == '"') {
                state = FSM_READ;
                return STRING;
            } else
                str_push(&str, c);
            break;

        case FSM_ESCAPE:
            c = fgetc(input);
            if(c == 'n') {
                state = FSM_STRING;
                str_push(&str, '\n');
            } else if(c == 't') {
                state = FSM_STRING;
                str_push(&str, '\t');
            } else if(c == '\\' || c == '"') {
                state = FSM_STRING;
                str_push(&str, c);
            } else if(isdigit(c))
                state = FSM_ESCAPE_NUM;
            else {
                state = FSM_START;
                return ERROR_LEX_ESC_SEC;
            }
            break;

        case FSM_ESCAPE_NUM:
            num = c - '0';
            c = fgetc(input);
            if(isdigit(c)) {
                num = num * 10 + c - '0';
                state = FSM_ESCAPE_NUM2;
            }
            else {
                state = FSM_START;
                return ERROR_LEX_ESC_SEC;
            }
            break;

        case FSM_ESCAPE_NUM2:
            c = fgetc(input);
            if(isdigit(c)) {
                num = num * 10 + c - '0';
                if(num > 0 && num < 256) {
                    str_push(&str, num);
                    state = FSM_STRING;
                } else {
                    state = FSM_START;
                    return ERROR_LEX_ESC_SEC;
                }
            } else {
                state = FSM_START;
                return ERROR_LEX_ESC_SEC;
            }
            break;

        case FSM_DASH:
            c = fgetc(input);
            if(c == '-')
                state = FSM_DASH2;
            else {
                state = FSM_START;
                return MINUS;
            }
            break;

        case FSM_DASH2:
            c = fgetc(input);
            if(c == '[')
                state = FSM_DASH2B;
            else if(c == '\n')
                state = FSM_READ;
            else
                state = FSM_COMMENT_LINE;
            break;

        case FSM_DASH2B:
            c = fgetc(input);
            if(c == '[')
                state = FSM_COMMENT_BLOCK;
            else
                state = FSM_COMMENT_LINE;
            break;

        case FSM_COMMENT_LINE:
            c = fgetc(input);
            if(c == '\n') {
                state = FSM_READ;
                ++line;
            } else if(c == EOF)
                return NOTHING;
            break;

        case FSM_COMMENT_BLOCK:
            c = fgetc(input);
            if(c == ']')
                state = FSM_COMMENT_BLOCK_END;
            else if(c == '\n')
                ++line;
            else if(c == EOF)
                return ERROR_LEX_X_CMNT_END;
            break;

        case FSM_COMMENT_BLOCK_END:
            c = fgetc(input);
            if(c == ']')
                state = FSM_READ;
            else {
                state = FSM_COMMENT_BLOCK;
                if(c == '\n')
                    ++line;
            }
            break;

        case FSM_EQUALS:
            c = fgetc(input);
            if(c == '=') {
                state = FSM_READ;
                return EQUAL;
            } else {
                state = FSM_START;
                return ASSIGN;
            }
            break;

        case FSM_DOT:
            c = fgetc(input);
            if(c == '.') {
                state = FSM_READ;
                return STRCONCAT;
            } else {
                state = FSM_START;
                return ERROR_LEX_UX_CHAR;
            }
            break;

        case FSM_LESS:
            c = fgetc(input);
            if(c == '=') {
                state = FSM_READ;
                return LESS_EQ;
            } else {
                state = FSM_START;
                return LESS;
            }
            break;

        case FSM_GREAT:
            c = fgetc(input);
            if(c == '=') {
                state = FSM_READ;
                return GREAT_EQ;
            } else {
                state = FSM_START;
                return GREAT;
            }
            break;

        case FSM_NOT_EQUALS:
            c = fgetc(input);
            if(c == '=') {
                state = FSM_READ;
                return NOT_EQUAL;
            } else {
                state = FSM_START;
                return ERROR_LEX_UX_CHAR;
            }
            break;

#ifdef DEBUG
        // konecny automat by nemel vypadnout do jineho stavu
        default:
            assert(0);
            break;
#endif
        } /* switch */
    } /* for */
}
Пример #26
0
/* insert new node into config tree and return a pointer to it
 * if *tree is NULL, it will be set to point to the root node */
conf_node *add_keyword(conf_node **tree, const char *keyword, const void *data, ssize_t size) {
	conf_node	*new_node, *cur_node;
	char		*key, *subkey;

	cur_node	= *tree;
	new_node	= NULL;
	key		= NULL;
	subkey		= NULL;


	if (!keyword) {
		logmsg(LOG_WARN, 1, "Warning - Unable to extend configuration tree: No keyword given.\n");
		return(*tree);
	}

	// check whether a prefix does already exist and if not, add it recursively
	if ((key = strdup(keyword)) ==  NULL) {
		logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n");
		return(NULL);
	}

	/* add recursively */
	if ((cur_node = check_keyword(*tree, key)) == NULL) {
		if ((subkey = strrchr(key, '.')) != NULL) {
			subkey[0] = 0;		// zero-terminate first half
			subkey++;		// pointer to second half
			if (isdigit(subkey[0])) {
				if ((cur_node = check_keyword(*tree, key)) == NULL)
					if ((cur_node = add_keyword(tree, key, NULL, 0)) == NULL) return(NULL);
				if (add_list_item(cur_node, data, size) == NULL) {
					fprintf(stderr, "  Error - Unable to add list item for %s.\n", key);
					return(NULL);
				}
				return(cur_node);
			}
			if ((cur_node = add_keyword(tree, key, NULL, 0)) == NULL) return(NULL);
		}
	} else return(cur_node);

	// create new node and insert it into tree
	if ((new_node = malloc(sizeof(conf_node))) == NULL) {
		logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n");
		free(key);
		return(NULL);
	}
	memset(new_node, 0, sizeof(conf_node));
	// if keyword is a toplevel key, add it, else add subkey
	if ((new_node->keyword = strdup(subkey ? subkey : key)) == NULL) {
		logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n");
		free(key);
		return(NULL);
	}
	free(key);

	if (size) {
		if (add_list_item(new_node, data, size) == NULL) {
			fprintf(stderr, "  Error - Unable to add list item for %s.\n", keyword);
			return(NULL);
		}
	}

	/* insert new node into tree */
	if (cur_node) {
		/* it's an internal node */
		if (cur_node->first_leaf) {
			cur_node = cur_node->first_leaf;
			while (cur_node->next) cur_node = cur_node->next;
			cur_node->next = new_node;
		} else cur_node->first_leaf = new_node;
	} else {
		/* it's a top level node */
		if (!(*tree)) (*tree) = new_node;
		/* it's a root's neighbor */
		else {
			cur_node = *tree;
			while (cur_node->next) cur_node = cur_node->next;
			cur_node->next = new_node;
		}
	}
	if (*tree == NULL) *tree = cur_node;

	return(new_node);
}
Пример #27
0
/* return first leaf node of subtree for given keyword */
conf_node *conf_subtree(conf_node *tree, const char *keyword) {
	conf_node *subtree;

	if ((subtree = check_keyword(tree, keyword)) == NULL) return(NULL);
	return(subtree->first_leaf);
}