Пример #1
0
void initPhoneBookEntry(phoneBookEntry* entry)
{
    initString(entry->firstName);
    initString(entry->lastName);
    initString(entry->mInitial);
    initString(entry->mobileNumber);
}
Пример #2
0
void addEntryPhoneBook(phoneBookEntry entry, phoneBook* simpon)
{
    stdclrscr();
    printf("Adding a new Contact Entry for Entry Slot #%d", (simpon->count + 1));
    newline();
    printlnPhoneBookEntry(entry);
    newline();
    if (hasEntrySlot(*simpon)) {
        char msg[MAXSTR];
        char intStr[MAXSTR];

        /* initialize strings before using them */
        initString(msg);
        initString(intStr);

        copyPhoneBookEntry (entry, &simpon->entry[simpon->count++]);
        strcat(msg, "Added Contact Entry Slot #");
        itoa(simpon->count, intStr, 10);
        strcat(msg, intStr);

        printlnInfoMessage(msg);
    } else {
        printlnInfoMessage("[simpon] is FULL . . .");
        printlnInfoMessage("Cannot add a new Contact Entry . . .");
    }
}
Пример #3
0
/*Create a new String
 *invoked by:OPC_LDC
 */
O createJstring(char *s)
{
    if (java_lang_String == NULL)
        java_lang_String = loadClass("java/lang/String");

    ClassBlock_t *cb = CLASS_CB(java_lang_String);

    if (!inited)
        initString();

    O char_obj, string_obj;
    FieldBlock_t *fb;
    int length, offset;

    length = strlen(s);
    char_obj = char2Char(s);

    short *data = (short *) char_obj->data;
    unsigned char *ss = (unsigned char *) s;
    convertUtf8(ss, data);

    string_obj = allocObject(java_lang_String);
    string_obj->type = OBJECT_STRING;
    OBJECT_DATA(string_obj, value_offset - 1, O) = char_obj;
    OBJECT_DATA(string_obj, count_offset - 1, int) = length;
    //*(((Object**)string_obj->data)+offset-1) = char_obj;

    string_obj->cb = cb;
    string_obj->el_size = sizeof(int);

    return string_obj;

}
Пример #4
0
void toUpperCaseFirstOnly(char src[MAXSTR], char dst[MAXSTR]) {
    int len = strlen(src);
    int i;

    initString(dst);

    if (len <= 0) {
        strcpy(dst, "<empty>");
    } else {
        if (len <= 1) {
            dst[0] = toupper(src[0]);
            dst[1] = '\0';
        }
        else {
            boolean isBeforeSpace = False;
            dst[0] = toupper(src[0]);
            for (i = 1; i < len; i++) {
                if (isBeforeSpace) {
                    dst[i] = toupper(src[i]);
                    isBeforeSpace = False;
                }
                else
                    dst[i] = tolower(src[i]);

                if (isspace(src[i]))
                    isBeforeSpace = True;
            }
            dst[i] = '\0';
        }
    }
}
Пример #5
0
static void process_buffer_acsint(struct synth_t *s, char *buf,
								  ssize_t length)
{
	int start = 0;
	int i;
	int flushIt = 0;

	while (start < length) {
		for (i = start; i < length; i++) {
			if (buf[i] == '\r' || buf[i] == '\n')
				flushIt = 1;
			if (buf[i] >= 0 && buf[i] < ' ')
				break;
		}
		if (i > start)
			stringAndBytes(&textAccumulator, &textAccumulator_l,
						   buf + start, i - start);
		if (flushIt) {
			if (textAccumulator != EMPTYSTRING) {
				queue_add_text(textAccumulator, textAccumulator_l);
				free(textAccumulator);
				textAccumulator = initString(&textAccumulator_l);
			}
			flushIt = 0;
		}
		if (i < length)
			start = i = i + process_command(s, buf, i);
		else
			start = length;
	}
}
Пример #6
0
String toPrefix (String postfix) {
	
	STACK_p_t stack = initStack();
	
	int l = (int)strlen(postfix), i;
	
	for (i = 0; i < l; ++i) {
		char z = *(postfix + i);
		
		if (isOperand(z)) {
			String tempString = initString(2);
			snprintf(tempString, 2, "%c", z);
			push(stack, tempString);
		}
		
		else if (isOperator(z)) {
			String tempString = (char *)malloc(SIZE * sizeof(char));
			snprintf(tempString, SIZE, "%s%s%c", pop(stack), pop(stack), z);
			push(stack, tempString);
		}
		
	}
	
	reverse(*(stack->arr));
	return *(stack->arr);
}
Пример #7
0
void initMutableString() {
	initString();
	
	if ( ! MutableStringClass )
		MutableStringClass = new(StringClass, "MutableStringClass", StringClass, sizeof(struct MutableStringClass),
						 constructor, MutableStringClass_constructor, NULL);
	if ( ! MutableString )
		MutableString = new(MutableStringClass, "MutableString", String, sizeof(struct MutableString),
					constructor, MutableString_constructor,
					destructor, MutableString_destructor,
					
					/* Overrides */
					copy, MutableString_copy,
					equals, MutableString_equals,
					getStringLength, MutableString_getStringLength,
					
					/* new */
					appendString, MutableString_appendString,
					appendFormat, MutableString_appendFormat,
					setString, MutableString_setString,
					setMutableStringLength, MutableString_setMutableStringLength,
					insertStringAtMutableStringIndex, MutableString_insertStringAtMutableStringIndex,
					deleteMutableStringCharactersInRange, MutableString_deleteMutableStringCharactersInRange,
					NULL);
}
Пример #8
0
/* start a document.write */
void dwStart(void)
{
	if (cw->dw)
		return;
	cw->dw = initString(&cw->dw_l);
	stringAndString(&cw->dw, &cw->dw_l, "<!DOCTYPE public><body>");
}				/* dwStart */
Пример #9
0
TNODE_p_t initNode (String data) {
	TNODE_p_t node = (TNODE_p_t)malloc(sizeof(TNODE_t));
	node->data = initString(SIZE);
	strcpy(node->data, data);
	node->left = NULL;
	node->right = NULL;
	return node;
}
Пример #10
0
void ByteArray::empty() 
{
	if (m_stringLength) 
	{
		s_memoryPool->get(m_dataCapacity)->deallocate(m_data);
		initString();
	}
}
Пример #11
0
NODE_p_t initNode (String data) {
	NODE_p_t node = (NODE_p_t)malloc(sizeof(NODE_t));
	node->data = initString(SIZE);
	strcpy(node->data, data);
	node->next = node;
	node->prev = node;
	return node;
}
Пример #12
0
/**
 * An example of input, considering an enter is is valid and empty string.
 */
void getline(char str[MAXSTR])
{
    initString(str);

    /* flush the buffer to get an empty buffer to avoid error. */
    fflush(stdin);
    fgets(str, MAXSTR, stdin);
    str[strlen(str)-1] = '\0';
}
Пример #13
0
void toUpperCase(char src[MAXSTR], char dst[MAXSTR]) {
    int len = strlen(src);
    int i;

    initString(dst);
    if (len <= 0) {
        strcpy(dst, "<empty>");
    } else {
        for (i = 0; i < len; i++)
            dst[i] = toupper(src[i]);
        dst[i] = '\0';
    }
}
Пример #14
0
OSCData::OSCData(char type, const char* data) :
    _type(type) {
    switch (_type) {
    case 'i':
        _length = 4;
        _buffer = new char[4];
        memcpy(_buffer, data, 4);
        break;
    case 's':
        initString(data);
        break;
    }
}
Пример #15
0
int main()
{
    myString *fat, *son;
    char in;
    int result = 0;

    initString( &fat );
    initString( &son );

    printf("请输入父串(以#号结束):");

    scanf("%c", &in);
    while( '#'!=in && fat->lenght < MAXSIZE)
    {
        fat->data[fat->lenght++] = in;
        scanf("%c", &in);
    }

    printf("请输入子串(以#号结束):");

    scanf("%c", &in);
    scanf("%c", &in);
    while( '#'!=in && son->lenght < MAXSIZE )
    {
        son->data[son->lenght++] = in;
        scanf("%c", &in);
    }

    result = compareString( *fat, *son );

    if( result )
        printf("父串包含子串。");
    else
        printf("不包含。");


    return 0;
}
Пример #16
0
int main (int argc, const char * argv []) {

    char ch;
    String string = initString(SIZE);
    String substring = initString(SIZE);
    do {
        printf("\n\tEnter the string: ");
        scanf(" %s", string);
        printf("\tEnter the substring: ");
        scanf(" %s", substring);

        if (containsString(string, substring))
            printf("\n\t'%s' is contained in '%s'.", substring, string);
        else
            printf("\n\t'%s' is not present in '%s'.", substring, string);

        printf("\n\tContinue (y/n): ");
        scanf(" %c", &ch);

    } while (ch == 'y');

    printf("\n\n");

}
Пример #17
0
bool
showTables(void)
{
    char tabname[40];
    char tabtype[40];
    char tabowner[40];
    SQLLEN tabnameOut, tabtypeOut, tabownerOut;
    char *buf;
    int buflen, cx;
    int truevalue = SQL_TRUE;

/*
SQLSetConnectAttr(hdbc, SQL_ATTR_METADATA_ID,
&truevalue, SQL_IS_INTEGER);
*/

    newStatement();
    stmt_text = "get tables";
    debugStatement();
    rc = SQLTables(hstmt,
       NULL, SQL_NTS, NULL, SQL_NTS, NULL, SQL_NTS, NULL, SQL_NTS);
    if(rc)
	goto abort;

    SQLBindCol(hstmt, 2, SQL_CHAR, (SQLPOINTER) tabowner, sizeof (tabowner),
       &tabownerOut);
    SQLBindCol(hstmt, 3, SQL_CHAR, (SQLPOINTER) tabname, sizeof (tabname),
       &tabnameOut);
    SQLBindCol(hstmt, 4, SQL_CHAR, (SQLPOINTER) tabtype, sizeof (tabtype),
       &tabtypeOut);

    buf = initString(&buflen);
    while(SQLFetch(hstmt) == SQL_SUCCESS) {
	char tabline[140];
	sprintf(tabline, "%s.%s|%s\n", tabowner, tabname, tabtype);
	stringAndString(&buf, &buflen, tabline);
    }

    cx = sideBuffer(0, buf, buflen, 0, false);
    nzFree(buf);
    i_printf(MSG_ShowTables, cx);
    SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
    return true;

  abort:
    SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
    return false;
}				/* showTables */
// ***********************************************
// ******              Inverter as letras   ******
// ***********************************************
void inverteFrase(Lista S)
{
char frase[40];
char c;
int pos,i = 0;




   if ( S.inicio == NULL)
      printf("Lista Vazia\n");
   else {

      tNo* posAtual = S.inicio;


        do
        {
          frase[i] = posAtual->caractere;
          posAtual = posAtual->prox;
          i++;
          pos++;
        }while(posAtual != NULL);

        pos=S.tam;
        initString(&S);

        do
        {
          c = frase[pos];
          if(c == 91)
          {
          inserirItem(&S,' ');
          }else
          {
            inserirItem(&S,c);
          }
          //printf("%c",c);
           pos--;
        }while((pos >= 0 )||( c >= 48)&&(c <= 125));

      }
    printf("\n");


	imprimeLista(S);
}
Пример #19
0
/**
 * Will replace invalid value as X
 */
void toMobileNumberFormat(char src[12], char dst[14])
{
    int i, j;

    if (strlen(src) == 0) {
        strcpy(dst, "<empty>");
        return;
    }

    initString(dst);
    /* dddd-ddd-dddd */
    for (i = 0, j = 0; i < 4; i++)
        dst[j++] = src[i] == ' ' ? '0' : src[i];
    dst[j++] = '-';
    for (i = 0; i < 3; i++) {
        switch (src[i+4]) {
            case '0': case '1': case '2':
            case '3': case '4': case '5':
            case '6': case '7': case '8':
            case '9': {
                dst[j++] = src[i+4];
                break;
            }
            default: {
                dst[j++] = 'X';
                break;
            }
        }
    }
    dst[j++] = '-';
    for (i = 0 ; i < 4; i++)
        switch (src[i+7]) {
            case '0': case '1': case '2':
            case '3': case '4': case '5':
            case '6': case '7': case '8':
            case '9': {
                dst[j++] = src[i+7];
                break;
            }
            default: {
                dst[j++] = 'X';
                break;
            }
        }
    dst[j] = '\0';
}
Пример #20
0
/* call javascript function with arguments, but all args must be objects */
static int run_function(jsobjtype obj, const char *name, int argc,
			const jsobjtype * argv)
{
	int rc;
	propval = 0;		/* should already be 0 */
	if (!allowJS || !cw->winobj || !obj)
		return -1;

	debugPrint(5, "> call %s(%d)", name, argc);

	if (argc) {
		int i, l;
		char oval[20];
		propval = initString(&l);
		for (i = 0; i < argc; ++i) {
			sprintf(oval, "%p|", argv[i]);
			stringAndString(&propval, &l, oval);
		}
	}

	head.cmd = EJ_CMD_CALL;
	head.n = strlen(name);
	head.obj = obj;
	head.proplength = 0;
	if (propval)
		head.proplength = strlen(propval);
	if (writeHeader())
		return -1;
	if (writeToJS(name, head.n))
		return -1;
	if (propval) {
		rc = writeToJS(propval, head.proplength);
		nzFree(propval);
		propval = 0;
		if (rc)
			return -1;
	}
	if (readMessage())
		return -1;
	ack5();
	return 0;
}				/* run_function */
Пример #21
0
static char *qpEncode(const char *line)
{
	char *newbuf;
	int l;
	const char *s;
	char c;

	newbuf = initString(&l);
	for (s = line; (c = *s); ++s) {
		if (c < '\n' && c != '\t' || c == '=') {
			char expand[4];
			sprintf(expand, "=%02X", (uchar) c);
			stringAndString(&newbuf, &l, expand);
		} else {
			stringAndChar(&newbuf, &l, c);
		}
	}

	return newbuf;
}				/* qpEncode */
Пример #22
0
TNODE_p_t createNode () {
	
	TNODE_p_t root;
	String data = initString(SIZE);
	
	printf("\tEnter data (# for break): ");
	scanf(" %s", data);
	
	if (*data == '#')
		return NULL;
	
	root = initNode(data);
	
	printf("\t Left of '%s' | ", root->data);
	root->left = createNode();
	
	printf("\tRight of '%s' | ", root->data);
	root->right = createNode();
	
	return root;
}
Пример #23
0
int main (int argc, const char * argv []) {
	
	NODE_p_t stack = initNode("<HEAD>");
	
	int choice;
	do {
		printf("\n\t1. Push\n\t2. Pop\n\t3. Display\n\t4. Display (with address)\n\tChoice: ");
		scanf(" %d", &choice);
		
		if (choice == 1) {
			String data = initString(SIZE);
			printf("\n\tEnter item to be pushed: ");
			scanf(" %s", data);
			push(&stack, data);
		}
		
		else if (choice == 2) {
			if (!isEmpty(stack)) {
				NODE_p_t temp = pop(&stack);
				printf("\n\tPopped item: %s (%p)\n", temp->data, temp);
			}
			else
				printf("\n\tSTACK UNDERFLOW!");
		}
		
		else if (choice == 4) {
			if (!isEmpty(stack)) {
				printf("\n\tCurrent Stack: ");
				displayWithAddress(stack);
			}
		}
		
		if (!isEmpty(stack)) {
			printf("\n\tCurrent Stack: ");
			display(stack);
		}
		
	} while (choice >= 1 && choice <= 4);
	
}
Пример #24
0
char *tidyPreprocess(const char *h)
{
	char *ns;		/* the new string */
	int l;
	char *inside, *expanded;
	const char *lg, *s = strstrCI(h, "<textarea");
/* most web pages don't have textareas */
	if (!s)
		return NULL;
	ns = initString(&l);
	stringAndBytes(&ns, &l, h, s - h);
	h = s;
	while (true) {
/* next textarea */
		s = strstrCI(h, "<textarea");
		if (!s)
			break;
		s = strchr(s, '>');
		if (!s)
			break;
		++s;
		stringAndBytes(&ns, &l, h, s - h);
		h = s;
		s = strstrCI(h, "</textarea");
		if (!s)
			break;
		lg = strpbrk(h, "<>");
/* lg is at most s */
		if (lg == s)
			continue;
		inside = pullString1(h, s);
		expanded = htmlEscapeTextarea(inside);
		stringAndString(&ns, &l, expanded);
		nzFree(inside);
		nzFree(expanded);
		h = s;
	}
	stringAndString(&ns, &l, h);
	return ns;
}				/* tidyPreprocess */
Пример #25
0
bool srdf::Model::initFile(const urdf::ModelInterface &urdf_model, const std::string& filename)
{
  // get the entire file
  std::string xml_string;
  std::fstream xml_file(filename.c_str(), std::fstream::in);
  if (xml_file.is_open())
  {
    while (xml_file.good())
    {
      std::string line;
      std::getline(xml_file, line);
      xml_string += (line + "\n");
    }
    xml_file.close();
    return initString(urdf_model, xml_string);
  }
  else
  {
    logError("Could not open file [%s] for parsing.", filename.c_str());
    return false;
  }
}
Пример #26
0
/* If debug is at least 5, show a simple acknowledgement or error
 * from the js process. */
static void ack5(void)
{
	char *a;
	int a_l;
	char buf[32];
	if (debugLevel < 5)
		return;
	a = initString(&a_l);
	stringAndChar(&a, &a_l, '<');
	if (head.highstat) {
		sprintf(buf, " error %d|%d", head.highstat, head.lowstat);
		stringAndString(&a, &a_l, buf);
	}
	stringAndChar(&a, &a_l, ' ');
	if (propval)
		stringAndString(&a, &a_l, debugString(propval));
	else if (head.cmd == EJ_CMD_HASPROP)
		stringAndNum(&a, &a_l, head.proptype);
	else
		stringAndString(&a, &a_l, "ok");
	debugPrint(5, "%s", a);
	nzFree(a);
}				/* ack5 */
Пример #27
0
/* set document.cookie to the cookies relevant to this url */
static void docCookie(jsobjtype d)
{
	int cook_l;
	char *cook = initString(&cook_l);
	const char *url = cw->fileName;
	bool secure = false;
	const char *proto;
	char *s;

	if (url) {
		proto = getProtURL(url);
		if (proto && stringEqualCI(proto, "https"))
			secure = true;
		sendCookies(&cook, &cook_l, url, secure);
		if (memEqualCI(cook, "cookie: ", 8)) {	/* should often happen */
			strmove(cook, cook + 8);
		}
		if (s = strstr(cook, "\r\n"))
			*s = 0;
	}

	set_property_string(d, "cookie", cook);
	nzFree(cook);
}				/* docCookie */
Пример #28
0
OSCData::OSCData(const char* value) :
    _type('s'),
    _length(0),
    _buffer(NULL) {
    initString(value);
}
Пример #29
0
TToken* get_token()
{	
    if(token_buffer != NULL)
    {
        token = token_buffer;
        token_buffer = NULL;
        return token;
    }
        
	TString buffer; 
	States state = S_START;
	char a[2]; // array for hex number
	int c, i=0;

	initString(&buffer, STR_DEFAULT_SIZE); 
	token->data = buffer.data;
	while(1)
	{
		c = fgetc(fp);
		switch(state)
		{
		case S_START:
			switch (c)
			{
				case EOF:
					token->type = TOKEN_EOF;
					return token;
				case '+':
					token->type = TOKEN_ADD;
					return token;
				case '-':
					token->type = TOKEN_SUB;
					return token;
				case '*':
					token->type = TOKEN_MUL;
					return token;
				case '/':
					state = S_DIV;
				    break;
				case '=':
					state = S_ASSIGN;
				    break;
				case '!':
					state = S_EXCM;
				    break;
				case '<':
					state = S_LESS;
				    break;
				case '>':
					state = S_GREAT;
				    break;		
				case '(':
					token->type = TOKEN_LROUND_BRACKET;
					return token;
				case ')':
					token->type = TOKEN_RROUND_BRACKET;
					return token;
				case '{':
					token->type = TOKEN_LCURLY_BRACKET;
					return token;
				case '}':
					token->type = TOKEN_RCURLY_BRACKET;
					return token;	
				case ',':
					token->type = TOKEN_COMMA;
					return token;
				case ';':
					token->type = TOKEN_SEMICOLON;
				    return token;
                case '"':
					state = S_QUOT;
				    break;
				default:
					if(isdigit(c))
					{
						state = S_INT;
						insertIntoString(&buffer, c);	
					}
					else if (isalpha(c) || c == '_')
					{
						state = S_IDENT;
						insertIntoString(&buffer, c);
					}
					else if (isspace(c))
						break;	
					else
						state = S_ERROR;								
			}
		    break;

//********************************************** 
		case S_INT: // INTEGER
			if (isdigit(c))
			{
				insertIntoString(&buffer, c);
			}
			else if(c == '.')
			{
				insertIntoString(&buffer, c);
				state = S_DOT;				
			}
			else if(c == 'E' || c == 'e')
			{
				insertIntoString(&buffer, c);
				state = S_EXPO_E;				
			}
			else
			{
				insertIntoString(&buffer, 0);
				ungetc(c,fp);
				token->type = TOKEN_INT_VALUE;
	            token->data = buffer.data;
				return token;
			}
		    break;

//*************************************************
		case S_DOT: // number DOT
			if (isdigit(c))
			{
				insertIntoString(&buffer, c);
				state = S_DBL;
			}	
			else
			{
				state = S_ERROR;
			}
		    break;

//*************************************************
		case S_DBL: // DOUBLE
			if (isdigit(c))
			{
				insertIntoString(&buffer, c);
			}
			else if(c == 'E' || c == 'e')
			{
				insertIntoString(&buffer, c);
				state = S_EXPO_E;				
			}
			else
			{
				insertIntoString(&buffer, 0);
				ungetc(c,fp);
				token->type = TOKEN_DOUBLE_VALUE;
	            token->data = buffer.data;
				return token;
			}
		    break;

//******************************************************
		case S_EXPO_E: // state S_EXPO_E
			if (isdigit(c))
			{
				insertIntoString(&buffer, c);
				state = S_EXPO;
			}
			else if (c == '+' || c == '-')
			{
				insertIntoString(&buffer, c);
				state= S_EXPO_M;				
			}		
			else
			{
				state = S_ERROR;
			}
		    break;			

//*****************************************************
		case S_EXPO_M: // state S_EXPO_M
			if (isdigit(c))
			{
				insertIntoString(&buffer, c);
				state= S_EXPO;
			}		
			else
			{
				state=S_ERROR;
			}
		    break;	

//*****************************************************
		case S_EXPO: // state S_EXPO
			if (isdigit(c))
				insertIntoString(&buffer, c);
			else
			{
				insertIntoString(&buffer, 0);
				ungetc(c,fp);
				token->type = TOKEN_DOUBLE_VALUE;
	            token->data = buffer.data;
				return token;
			}
		    break;
		
//***************************************************
		case S_IDENT: //STATE IDENTIFIER
			if (isalnum(c) || c == '_')
			{
				insertIntoString(&buffer, c);
			}
			else
			{
				insertIntoString(&buffer, 0);
				token->type = TOKEN_IDENTIFIER;
	            token->data = buffer.data;
				keyword_check();
				ungetc(c,fp);
				return token;
			}
		    break;
//*************************************************************
		case S_DIV: // DIVIDE
			if (c == '/')
				state = S_LCOM;
			else if (c == '*')
				state = S_LBC;			
			else
			{
				ungetc(c,fp);
				token->type = TOKEN_DIV;
				return token;
			}
		    break;	

//***************************************************
		case S_LCOM: // LINE COMMENT
			if (c == '\n')
				state = S_START;
		    break;
				
//****************************************************
		case S_LBC: // LEFT BLOCK COMMENT
			if (c == '*')
				state = S_RBC;
			if(c == EOF)
				state = S_ERROR;
		    break;

//****************************************************
		case S_RBC: //RIGHT BLOCK COMMENT
			if (c == '/')
				state = S_START;
			else if (c == EOF)
				state = S_ERROR;
			else if (c == '*');
			else
				state = S_LBC;
		break;
				
//****************************************************
		case S_ASSIGN: // ASSIGNMENT
			if (c == '=')
			{
				token->type = TOKEN_EQUAL;
				return token;
			}			
			else
			{
				ungetc(c,fp);
				token->type = TOKEN_ASSIGN;
				return token;
			}
	      	 break;	
	
//****************************************************
		case S_EXCM: // EXCLAMATION MARK
			if (c == '=')
			{
				token->type = TOKEN_NOT_EQUAL;
				return token;
			}			
			else
				state = S_ERROR;
		   break;	

//****************************************************
		case S_LESS: // LESS THAN
			if (c=='=')
			{
				token->type=TOKEN_LESS_EQUAL;
				return token;
			}
			else if (c == '<')
			{
				token->type=TOKEN_COUT_BRACKET;
				return token;
			}				
			else
			{
				ungetc(c,fp);
				token->type = TOKEN_LESS;
				return token;
			}
		   break;

//****************************************************
		case S_GREAT: //GREATER THAN
			if (c=='=')
			{
				token->type = TOKEN_GREATER_EQUAL;
				return token;
			}
			else if (c == '>')
			{
				token->type = TOKEN_CIN_BRACKET;
				return token;
			}				
			else
			{
				ungetc(c,fp);
				token->type = TOKEN_GREATER;
				return token;
			}
		   break;

//****************************************************
		case S_QUOT: //QUOTATION
			if (c == '"') 
			{ 
				insertIntoString(&buffer, 0); 
				token->type = TOKEN_STRING_VALUE;
	            token->data = buffer.data;
				return token;
			}
			else if(c == EOF)
			{
				state = S_ERROR;
			}
			else if(c == '\\')
			{
				state = S_ESCAPE;
			}
			else if(c > 31)
			{
				insertIntoString(&buffer, c);
			}
            else
                state = S_ERROR;
		   break;

//****************************************************
		case S_ESCAPE: //ESCAPE SEQUENCES
			if (c == 't')
			{
				insertIntoString(&buffer, '\t');
				state = S_QUOT;
			}
			else if (c == '"')
			{
				insertIntoString(&buffer, '"');
				state = S_QUOT;
			}
			else if (c == '\\')
			{
				insertIntoString(&buffer, '\\');
				state = S_QUOT;
			}
			else if (c == 'n')
			{
				insertIntoString(&buffer, '\n');
				state = S_QUOT;
			}
			else if (c == 'x')
			{
				state = S_HEX_NUMBER;
			}
			else
			{
				state=S_ERROR;	
			}
			break;

//****************************************************	
		case S_HEX_NUMBER: // HEXADECIMAL NUMBER
			if (isxdigit(c) && (i < 2)) // if is hexadigit and i<2
			{
				a[i]=c;
				i++;			
             
                if (i == 2)
                {
                	if ((a[0] == '0') && (a[1] == '0'))
						state=S_ERROR;
					else
					{
                    char hta = hex_to_ascii(a[0], a[1]);
                    insertIntoString(&buffer, hta);
                    state = S_QUOT;
                    i = 0;
                	}
                }
            }
			else
			{
				state=S_ERROR;
			}
			break;

//****************************************************
		case S_ERROR: // ERROR
			exit_error(E_LEX);
		}
	}
}
Пример #30
0
static int process_command(struct synth_t *s, char *buf, int start)
{
	char *cp;
	int value;
	enum adjust_t adj;
	enum command_t cmd;

	cp = buf + start;
	switch (*cp) {
	case 1:
		cp++;
		switch (*cp) {
		case '+':
			adj = ADJ_INC;
			cp++;
			break;
		case '-':
			adj = ADJ_DEC;
			cp++;
			break;
		default:
			adj = ADJ_SET;
			break;
		}

		value = 0;
		while (isdigit(*cp)) {
			value = value * 10 + (*cp - '0');
			cp++;
		}

		switch (*cp) {
		case 'b':
			cmd = CMD_SET_PUNCTUATION;
			break;
		case 'f':
			cmd = CMD_SET_FREQUENCY;
			break;
		case 'p':
			cmd = CMD_SET_PITCH;
			break;
		case 's':
			cmd = CMD_SET_RATE;
			break;
		case 'v':
			cmd = CMD_SET_VOLUME;
			break;
		default:
			cmd = CMD_UNKNOWN;
			break;
		}
		cp++;
		break;
	default:
		cmd = CMD_UNKNOWN;
		cp++;
		break;
	}

	if (cmd != CMD_FLUSH && cmd != CMD_UNKNOWN) {
		if (espeakup_mode == ESPEAKUP_MODE_ACSINT
			&& textAccumulator_l != 0) {
			queue_add_text(textAccumulator, textAccumulator_l);
			free(textAccumulator);
			textAccumulator = initString(&textAccumulator_l);
		}
		queue_add_cmd(cmd, adj, value);
	}

	return cp - (buf + start);
}