Esempio n. 1
0
	def delete_trigger (cls, object_key, trigger_condition, field_value):
		object_triggers = cls.get_object_triggers (object_key)
		if object_triggers != None:
			idx = None
			for id in object_triggers:
				if cls.__triggers[id].condition == trigger_condition:
					idx = id

			if idx != None:
				ConditionProvider.deactivate_trigger (idx)
				cls.__triggers.pop (idx)
				del (cls.__object_triggers[object_key])
Esempio n. 2
0
    def delete_trigger(cls, object_key, trigger_condition, field_value):
        object_triggers = cls.get_object_triggers(object_key)
        if object_triggers != None:
            idx = None
            for id in object_triggers:
                if cls.__triggers[id].condition == trigger_condition:
                    idx = id

            if idx != None:
                ConditionProvider.deactivate_trigger(idx)
                cls.__triggers.pop(idx)
                del (cls.__object_triggers[object_key])
Esempio n. 3
0
	def process_object_triggers (cls, object_key, object_value):
		deferred_activation = []
		object_triggers = cls.get_object_triggers (object_key)
		if object_triggers != None:
			for id in object_triggers:
				activate = False

				if cls.__triggers[id].condition == "":
					activate = True
				elif cls.__triggers[id].condition == "==":
					if str (object_value) == str (cls.__triggers[id].value):
						activate = True
				elif cls.__triggers[id].condition == "!=":
					if str (object_value) != str (cls.__triggers[id].value):
						activate = True
				elif cls.__triggers[id].condition == ">=":
					if object_value >= cls.__triggers[id].value:
						activate = True
				elif cls.__triggers[id].condition == "<=":
					if object_value <= cls.__triggers[id].value:
						activate = True
				elif cls.__triggers[id].condition == ">":
					if object_value > cls.__triggers[id].value:
						activate = True
				elif cls.__triggers[id].condition == "<":
					if object_value < cls.__triggers[id].value:
						activate = True
		
				if activate == True:
					if cls.__triggers[id].type == TriggerType.on_change:
						if cls.__triggers[id].active == True:
							cls.__triggers[id].active = False
							#print "D", cls.__triggers[id].condition, cls.__triggers[id].value
							ConditionProvider.deactivate_trigger (id)
					deferred_activation.append (id)
				else:
					#print "deact", object_key, cls.__triggers[id].condition, cls.__triggers[id].value, object_value
					if cls.__triggers[id].active == True:
						#print "D", cls.__triggers[id].condition, cls.__triggers[id].value
						cls.__triggers[id].active = False
						n = cls.__activated_triggers.count (id)
						if n != 0:
							cls.__activated_triggers.remove (id)
						ConditionProvider.deactivate_trigger (id)

			for id in deferred_activation:
				#print "act", object_key, cls.__triggers[id].condition, cls.__triggers[id].value, object_value
				if cls.__triggers[id].active == False:
					cls.__triggers[id].active = True
					cls.__activated_triggers.append (id)
					ConditionProvider.activate_trigger (id)
Esempio n. 4
0
    def process_object_triggers(cls, object_key, object_value):
        deferred_activation = []
        object_triggers = cls.get_object_triggers(object_key)
        if object_triggers != None:
            for id in object_triggers:
                activate = False

                if cls.__triggers[id].condition == "":
                    activate = True
                elif cls.__triggers[id].condition == "==":
                    if str(object_value) == str(cls.__triggers[id].value):
                        activate = True
                elif cls.__triggers[id].condition == "!=":
                    if str(object_value) != str(cls.__triggers[id].value):
                        activate = True
                elif cls.__triggers[id].condition == ">=":
                    if object_value >= cls.__triggers[id].value:
                        activate = True
                elif cls.__triggers[id].condition == "<=":
                    if object_value <= cls.__triggers[id].value:
                        activate = True
                elif cls.__triggers[id].condition == ">":
                    if object_value > cls.__triggers[id].value:
                        activate = True
                elif cls.__triggers[id].condition == "<":
                    if object_value < cls.__triggers[id].value:
                        activate = True

                if activate == True:
                    if cls.__triggers[id].type == TriggerType.on_change:
                        if cls.__triggers[id].active == True:
                            cls.__triggers[id].active = False
                            #print "D", cls.__triggers[id].condition, cls.__triggers[id].value
                            ConditionProvider.deactivate_trigger(id)
                    deferred_activation.append(id)
                else:
                    #print "deact", object_key, cls.__triggers[id].condition, cls.__triggers[id].value, object_value
                    if cls.__triggers[id].active == True:
                        #print "D", cls.__triggers[id].condition, cls.__triggers[id].value
                        cls.__triggers[id].active = False
                        n = cls.__activated_triggers.count(id)
                        if n != 0:
                            cls.__activated_triggers.remove(id)
                        ConditionProvider.deactivate_trigger(id)

            for id in deferred_activation:
                #print "act", object_key, cls.__triggers[id].condition, cls.__triggers[id].value, object_value
                if cls.__triggers[id].active == False:
                    cls.__triggers[id].active = True
                    cls.__activated_triggers.append(id)
                    ConditionProvider.activate_trigger(id)
Esempio n. 5
0
    def assign_priorities(cls):
        variables = []
        variables.append(None)
        variables_ids = {}
        var_procs_read = []
        var_procs_read.append(None)
        var_procs_write = []
        var_procs_write.append(None)
        preproc = []
        postproc = []
        postproc_ids = {}

        for hv in cls.__handler_variables:
            #print "hv", hv.id
            vi = 0
            if hv == None:
                continue
            for v in hv.variables:
                #print "v", v, hv.changeable[vi]
                id = variables_ids.get(v)
                #print "id", id
                if id == None:
                    i = len(variables)
                    #print "i", i
                    variables.append(v)
                    variables_ids[v] = i
                    var_procs_read.append([])
                    var_procs_write.append([])
                    if hv.changeable[vi] == False:
                        var_procs_read[i].append(hv.id)
                    else:
                        var_procs_write[i].append(hv.id)
                else:
                    found = False
                    if hv.changeable[vi] == False:
                        for vp in var_procs_read[id]:
                            if vp == hv.id:
                                found = True
                        if found == False:
                            var_procs_read[id].append(hv.id)
                    else:
                        for vp in var_procs_write[id]:
                            if vp == hv.id:
                                found = True
                        if found == False:
                            var_procs_write[id].append(hv.id)

                vi += 1
        """print "----"
		vi = 0
		for v in variables:
			if v != None:
				print "v", v
				for w in var_procs_write[vi]:
					print "w", w
				for r in var_procs_read[vi]:
					print "r", r
			vi += 1
		print "----"""

        vi = 0
        for v in variables:
            if v != None:
                for w in var_procs_write[vi]:
                    for r in var_procs_read[vi]:
                        #print r , "->", w
                        preproc.append(r)
                        postproc_ids[w] = len(postproc)
                        postproc.append(w)
            vi += 1
        return
        l = len(preproc)
        i = 0
        while i < l:
            if postproc_ids.get(preproc[i]):
                print "found"
            else:
                t = preproc[i][:1]
                id = int(preproc[i][1:])
                priority = 1
                #print t + str (id), priority
                if t == 'T':
                    TriggerProvider.set_priority(id, priority)
                elif t == 'C':
                    ConditionProvider.set_priority(id, priority)
                t = postproc[i][:1]
                id = int(postproc[i][1:])
                priority += 1
                #print t + str (id), priority
                if t == 'T':
                    TriggerProvider.set_priority(id, priority)
                elif t == 'C':
                    ConditionProvider.set_priority(id, priority)
            i += 1

        cls.__priorities_assigned = True
Esempio n. 6
0
	def replace_subtree (cls, root_node, side, is_new, cursor):
		actor, actant = PropositionTree.get_actor_and_actant (root_node)
		result_node = PropositionTreeNode ()
		result_node.type = PropositionTreeNodeType.concept
		result_node.side = side
		result_node.concept = TreeNodeConcept ()
		is_memobject = False
		error_text = ""

		if root_node.concept.name == LanguageHelper.translate ("to-have"):
			if actant.concept.name == LanguageHelper.translate ("name"):
				if actor.concept.name == LanguageHelper.translate ("module"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.concept:
								result_node.concept.type = TreeNodeConceptType.module
								result_node.concept.name = child2.concept.name
								result_node.text = result_node.concept.name
								is_memobject = True
				elif actor.concept.name == LanguageHelper.translate ("field"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.code_object:
								if is_new == True:
									result_node.concept.id = MemoryProvider.create_field (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.field
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_field_node (result_node)
								else:
									result_node.concept.id = MemoryProvider.get_field_id (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.field
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
				elif actor.concept.name == LanguageHelper.translate ("constant"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.code_object:
								if is_new == True:
									result_node.concept.id = MemoryProvider.create_constant (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.constant
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_constant_node (result_node)
								else:
									result_node.concept.id = MemoryProvider.get_constant_id (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.constant
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
				elif actor.concept.name == LanguageHelper.translate ("list"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.code_object:
								if is_new == True:
									result_node.concept.id = MemoryProvider.create_list (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.memlist
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_list_node (result_node)
								else:
									result_node.concept.id = MemoryProvider.get_list_id (child2.text)
									is_memobject = True
									result_node.concept.type = TreeNodeConceptType.memlist
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
				elif actor.concept.name == LanguageHelper.translate ("trigger"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.code_object:
								if is_new == True:
									result_node.concept.id = TriggerProvider.create_trigger (child2.text)
									result_node.concept.type = TreeNodeConceptType.trigger
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_trigger_node (result_node)
				elif actor.concept.name == LanguageHelper.translate ("condition"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.code_object:
								if is_new == True:
									result_node.concept.id = ConditionProvider.create_condition (child2.text)
									result_node.concept.type = TreeNodeConceptType.condition
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_condition_node (result_node)
							elif child2.type == PropositionTreeNodeType.concept:
								if is_new == True:
									result_node.concept.id = ConditionProvider.create_condition (child2.text)
									result_node.concept.type = TreeNodeConceptType.condition
									result_node.concept.name = "$" + str (result_node.concept.id)
									result_node.text = result_node.concept.name
									ContextProvider.set_condition_node (result_node)
				elif actor.concept.name == LanguageHelper.translate ("procedure"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.concept:
								database_triad = DatabaseTriad.read (cursor, actant.concept.id, child1.linkage.id, child2.concept.id)
								if database_triad == None:
									error_text = ErrorHelper.get_text (105)
									return None, error_text
								database_sequense1 = DatabaseSequence.read (cursor, 0, 0, database_triad.id)
								if database_sequense1 == None:
									error_text = ErrorHelper.get_text (105)
									return None, error_text
								database_triad = DatabaseTriad.read_by_id (cursor, database_sequense1.left_triad_id)
								if database_triad == None:
									error_text = ErrorHelper.get_text (105)
									return None, error_text
								if database_triad.left_concept_id == root_node.concept.id:
									database_sequense2 = DatabaseSequence.read (cursor, database_sequense1.proposition_id, 0, database_triad.id)
									if database_sequense2 == None:
										error_text = ErrorHelper.get_text (105)
										return None, error_text
									database_triad = DatabaseTriad.read_by_id (cursor, database_sequense2.left_triad_id)
									if database_triad == None:
										error_text = ErrorHelper.get_text (105)
										return None, error_text
									result_node.concept.id = database_triad.left_concept_id
									database_concept = DatabaseConcept.read_by_name (cursor, LanguageHelper.translate ("to-be"))
									if database_concept == None:
										error_text = ErrorHelper.get_text (104)
										return None, error_text
									database_triad1 = DatabaseTriad.read (cursor, result_node.concept.id, 0, database_concept.id)
									if database_triad1 == None:
										error_text = ErrorHelper.get_text (104)
										return None, error_text
									database_triad2 = DatabaseTriad.read (cursor, database_concept.id, 0, actor.concept.id)
									if database_triad2 == None:
										error_text = ErrorHelper.get_text (104)
										return None, error_text
									database_sequense3 = DatabaseSequence.read (cursor, 0, database_triad1.id, database_triad2.id)
									if database_sequense3 == None:
										error_text = ErrorHelper.get_text (104)
										return None, error_text
								else:
									error_text = ErrorHelper.get_text (105)
									return None, error_text
			elif actant.concept.name == LanguageHelper.translate ("class"):
				if actor.concept.name == LanguageHelper.translate ("trigger"):
					child1 = actant.children[0]
					if child1.type == PropositionTreeNodeType.linkage:
						if child1.linkage.name == LanguageHelper.translate ("which"):
							child2 = child1.children[0]
							if child2.type == PropositionTreeNodeType.string:
								result_node.concept.id = TriggerProvider.get_id_by_class (child2.text)
								result_node.concept.type = TreeNodeConceptType.trigger
								result_node.concept.name = "$" + str (result_node.concept.id)
								result_node.text = result_node.concept.name
								is_memobject = True
		if is_memobject != True:
			if result_node.concept.id != 0:
				database_concept = DatabaseConcept.read_by_id (cursor, result_node.concept.id)
				result_node.concept.type = database_concept.type
				result_node.concept.name = database_concept.name
				result_node.text = result_node.concept.name
			else:
				return None, error_text

		return result_node, error_text
Esempio n. 7
0
	def assign_priorities (cls):
		variables = []
		variables.append (None)
		variables_ids = {}
		var_procs_read = []
		var_procs_read.append (None)
		var_procs_write = []
		var_procs_write.append (None)
		preproc = []
		postproc = []
		postproc_ids = {}

		for hv in cls.__handler_variables:
			#print "hv", hv.id
			vi = 0
			if hv == None:
				continue
			for v in hv.variables:
				#print "v", v, hv.changeable[vi]
				id = variables_ids.get (v)
				#print "id", id
				if id == None:
					i = len (variables)
					#print "i", i
					variables.append (v)
					variables_ids[v] = i
					var_procs_read.append ([])
					var_procs_write.append ([])
					if hv.changeable[vi] == False:
						var_procs_read[i].append (hv.id)
					else:
						var_procs_write[i].append (hv.id)
				else:
					found = False
					if hv.changeable[vi] == False:
						for vp in var_procs_read[id]:
							if vp == hv.id:
								found = True
						if found == False:
							var_procs_read[id].append (hv.id)
					else:
						for vp in var_procs_write[id]:
							if vp == hv.id:
								found = True
						if found == False:
							var_procs_write[id].append (hv.id)

				vi += 1

		"""print "----"
		vi = 0
		for v in variables:
			if v != None:
				print "v", v
				for w in var_procs_write[vi]:
					print "w", w
				for r in var_procs_read[vi]:
					print "r", r
			vi += 1
		print "----"""

		vi = 0
		for v in variables:
			if v != None:
				for w in var_procs_write[vi]:
					for r in var_procs_read[vi]:
						#print r , "->", w
						preproc.append (r)
						postproc_ids[w] = len (postproc)
						postproc.append (w)
			vi += 1
		return
		l = len (preproc)
		i = 0
		while i < l:
			if postproc_ids.get (preproc[i]):
				print "found"
			else:
				t = preproc[i][:1]
				id = int (preproc[i][1:])
				priority = 1
				#print t + str (id), priority
				if t == 'T':
					TriggerProvider.set_priority (id, priority)
				elif t == 'C':
					ConditionProvider.set_priority (id, priority)
				t = postproc[i][:1]
				id = int (postproc[i][1:])
				priority += 1
				#print t + str (id), priority
				if t == 'T':
					TriggerProvider.set_priority (id, priority)
				elif t == 'C':
					ConditionProvider.set_priority (id, priority)
			i += 1

		cls.__priorities_assigned = True
Esempio n. 8
0
def main (single_run, use_ctl, use_dbg, text):
    exit = False
    db = MySQLdb.connect (host="localhost", user="******", passwd="qslbase", db="qslbase", charset="utf8")
    cursor = db.cursor ()
    result = ""
    sys.setdefaultencoding ("utf8")
    SyntaxAnalyzer (cursor)
    semantic_analyzer = SemanticAnalyzer (cursor)
    CodeProvider (cursor)
    CodeStack ()
    ErrorHelper (cursor)
    MemoryProvider ()
    ContextProvider ()
    TriggerProvider ()
    ConditionProvider ()
    DebuggerProvider (use_dbg)

    if single_run == False:
        stdin = os.open ("/tmp/qslime-std-in", os.O_RDONLY | os.O_NONBLOCK)
        stdout = os.open ("/tmp/qslime-std-out", os.O_WRONLY)
    if use_ctl == True:
        ctlout = os.open ("/tmp/qslime-ctl-out", os.O_WRONLY)
        ctlin = open ("/tmp/qslime-ctl-in", "r")
    if use_dbg == True:
        dbgout = os.open ("/tmp/qslime-dbg-out", os.O_WRONLY)
        dbgin = open ("/tmp/qslime-dbg-in", "r")
        DebuggerProvider.dbgin = dbgin
        DebuggerProvider.dbgout = dbgout
    if use_ctl == True:
        text = ctlin.readline ()
        if text != "":
            if SyntaxAnalyzer.analize (text):
                #PropositionTree.print_tree (SyntaxAnalyzer.proposition_tree)
                if semantic_analyzer.analize (SyntaxAnalyzer.proposition_tree, None):
                    #semantic_analyzer.proposition_tree.print_tree ()
                    result += semantic_analyzer.result
                    os.write (ctlout, 'OK.\n')
                else:
                    os.write (ctlout, semantic_analyzer.get_error_text () + '\n')
            else:
                os.write (ctlout, semantic_analyzer.get_error_text () + '\n')
    else:
        if text != "":
            #print text
            if DebuggerProvider.use == True:
                DebuggerProvider.reset ()
                DebuggerProvider.set_single_code_line (text)
                DebuggerProvider.build_debug_data ()
                DebuggerProvider.send_data ()
                DebuggerProvider.receive_data ()
            if SyntaxAnalyzer.analize (text):
                #SyntaxAnalyzer.proposition_tree.print_tree (SyntaxAnalyzer.proposition_tree)
                if semantic_analyzer.analize (SyntaxAnalyzer.proposition_tree, None):
                    #semantic_analyzer.proposition_tree.print_tree ()
                    result += semantic_analyzer.result
                else:
                    return semantic_analyzer.get_error_text ()
            else:
                return SyntaxAnalyzer.get_error_text ()

    while (exit != True):
        code_line = CodeStack.pop ()
        while (code_line != None):
            if code_line.text != "":
                #print code_line.text
                if DebuggerProvider.use == True:
                    if code_line.concept_id != 0 and code_line.id != 0:
                        DebuggerProvider.set_procedure_id (code_line.concept_id)
                        DebuggerProvider.set_line_id (code_line.id)
                    else:
                        DebuggerProvider.set_single_code_line (code_line.text)
                    DebuggerProvider.build_debug_data ()
                    DebuggerProvider.send_data ()
                    DebuggerProvider.receive_data ()
                analized = True
                if code_line.tree == None:
                    analized = SyntaxAnalyzer.analize (code_line.text)
                    tree = SyntaxAnalyzer.proposition_tree
                else:
                    tree = code_line.tree
                if analized:
                    #tree.print_tree (tree)
                    if semantic_analyzer.analize (tree, code_line):
                        #tree.print_tree (tree)
                        if code_line.tree != None:
                            if code_line.tree.is_totally_parsed == False:
                                code_line.tree = semantic_analyzer.proposition_tree
                                code_line.tree.is_totally_parsed = True
                        result += semantic_analyzer.result
                    else:
                        return semantic_analyzer.get_error_text ()
                else:
                    return SyntaxAnalyzer.get_error_text ()
                if CodeStack.is_empty () == True:
                    if CodeStack.inside_procedure == False:
                        if CodeProvider.is_priorities_assigned () == False:
                            CodeProvider.assign_priorities ()
                        TriggerProvider.dispatch_triggers ()
                        ConditionProvider.dispatch_conditions ()
                        CodeStack.sort ()
            else:
                if code_line.prev_line_id == -1 and code_line.concept_id != 0:
                    CodeProvider.execute_procedure (code_line.concept_id)
            code_line = CodeStack.pop ()

            if result != "" and single_run == False:
                #print result
                os.write (stdout, result)
                result = ""
                exit = True

        if single_run == True:
            return result

    os.close (stdin)
    os.close (stdout)
    os.close (ctlin)
    os.close (ctlout)
    os.close (dbgin)
    os.close (dbgout)