Exemplo n.º 1
0
func printStringElement(level int, word models.StringElement) {
	if word.Type() == models.ST_SEQ {
		for _, child := range word.Words {
			Par.Send(level, COL_BLUE_B, AddColors(COL_BLUE_U, "seq"))
			printStringElement(level+1, child)
		}
	} else {
		Par.Send(level, elementColors[word.XMLName.Local][0], //TODO simplify type string call
			AddColors(elementColors[word.XMLName.Local][1], word.XMLName.Local), word.Value)
		//PrintString(level, word)
	}
}
Exemplo n.º 2
0
func StepConvert(se *models.StringElement) *Step {
	val := NewStep(se.Value)
	switch se.Type() {
	case models.ST_SEQ:
		result := *seqConvert(se)
		ret := Step(&result)
		return &ret
	case models.ST_CLASS:
		result := ClassStep(val)
		ret := Step(&result)
		return &ret
	case models.ST_RULE:
		result := RuleStep(val)
		ret := Step(&result)
		return &ret
	case models.ST_TERM:
		result := TermStep(val)
		ret := Step(&result)
		return &ret
	}

	return nil
}
Exemplo n.º 3
0
//Main syntax parsing function
func Translate(word *models.StringElement, parentCursor *SeqIterator) (result bool) {
	deepInc()
	defer deepDec()

	cursor, element, error := GetCurrent(parentCursor)
	if isError(error) {
		return false
	}
	cursor.buffer.StringElement = *word
	switch word.Type() {
	case models.ST_CLASS:
		output.Par.SendPair(deep-1, COL_BLUE_B, "CLASS", word.Value,
			"curs.i", strconv.Itoa(cursor.int), (*element.Value).String())
		result = lexer.GetClassByName(word.Value) == element.Cat
	case models.ST_TERM:
		output.Par.SendPair(deep-1, COL_BLUE_B, "TERM", word.Value, (*element.Value).String())
		result = element.Name == word.Value
	case models.ST_RULE:
		output.Par.Send(deep-1, COL_BLUE_B, "RULE", word.Value)
		result = Translate(&GetRule(word.Value).TopWord, cursor)
	case models.ST_SEQ:
		output.Par.SendPair(deep, COL_BLUE_U, "SEQ", deep,
			"O", word.Optional,
			"C", word.Choises, "I", word.Iterative)
		checkChilds := func(curs *SeqIterator) bool {
			isLast := func(n int) bool {
				if n == len(word.Words)-1 {
					return true
				} else {
					return false
				}
			}
			for i, child := range word.Words {
				childResult := Translate(&child, curs)
				if word.Choises {
					if childResult {
						return true
					} else if isLast(i) {
						return false
					}
				} else {
					if childResult {
						if isLast(i) {
							return true
						}
					} else {
						return false
					}
				}
			}
			return false
		}

		if word.Iterative {
			Nrep := 0
			cycleCursor, error := InitIter(cursor)
			cycleCursor.buffer.XMLName.Local = string(models.ST_SEQ)
			if !isError(error) {
				for iterSucc := true; iterSucc; {
					iterSucc = checkChilds(cycleCursor)
					output.Par.SendPair(deep, COL_RED, iterSucc,
						Nrep, cursor.int, cycleCursor.int)
					if iterSucc {
						Nrep++
					}
				}
			}
			if Nrep > 0 {
				cycleCursor.ApplyToParent()
				result = true
			} else {
				result = false
			}
		} else {
			result = checkChilds(cursor)
		}
		if word.Optional && !result {
			result = true
			cursor.buffer = models.NewTreeNode()
			cursor.buffer.XMLName.Local = string(models.ST_SEQ)
			output.Par.Send(0, COL_DEEP_LIM, "OPTIONAL")
		}
	}
	if result {
		if word.Type() == models.ST_RULE ||
			word.Type() == models.ST_SEQ {
			cursor.ApplyToParent()
		} else {
			fmt.Println("Add to parent", *word, "|", *element)
			cursor.AddToParent(word, element)
		}
		output.Par.SendPair(deep, COL_GREEN, "RES", result, word.Type()) //TODO print output for failures too
	}
	return
}