Three-address code
http://dbpedia.org/resource/Three-address_code an entity of type: WikicatCompilers
Tříadresní kód (často označovaný jako tříadresný kód nebo tříadresový kód) označuje v informatice formu mezijazyka, používanou překladačem jako pomůcku pro optimalizaci kódu. Každý příkaz v tříadresním kódu je zapsán pomocí uspořádané čtveřice: operátor, operand1, operand2 a výsledek.
rdf:langString
3-어드레스 코드(Three-address code)는 컴파일러에서 사용되는 중간 언어의 한 종류로, 컴파일러 최적화를 실현하는데 사용된다. '3-어드레스'로 불리는 것은 2개의 입력용과 1개의 출력용 메모리 주소 혹은 레지스터를 지정하는 형식이기 때문이다.
rdf:langString
3アドレスコード（英: three-address code）とは、コンピュータ・プログラミング言語処理系などにおける中間表現などにおける形式の1パターンである。処理系においては、コンパイラ最適化などの処理を掛けるのに適している。2つの入力と1つの出力のアドレス（メモリまたはレジスタ）を指定する形式であるため、3アドレスコードと呼ばれる。命令セットアーキテクチャにおける「3オペランド」形式の類推とも言える。
rdf:langString
三位址碼（英語：Three address code，經常被縮寫為TAC 或 3AC），一種中間語言，編譯器使用它來改進程式碼轉換效率。每個三位址碼指令，都可以被分解為一個四元組（4-tuple）：（運算子，運算元1，運算元2，結果）。因為每個陳述都包含了至多三個（如：goto语句，仅含一个变数）變數，所以它被稱為三位址碼。
rdf:langString
En ciencias de la computación, el código de tres direcciones (en inglés: three address code, normalmente abreviado a TAC o 3AC) es un lenguaje intermedio usado por compiladores optimizadores para ayudar en las transformaciones de mejora de código. Cada instrucción TAC tiene a lo sumo tres operandos y es típicamente una combinación de asignación y operador binario. Por ejemplo, t1 := t2 + t3. El nombre proviene del uso de tres operandos en estas declaraciones aunque instrucciones con menos operandos pueden existir.
rdf:langString
In computer science, three-address code (often abbreviated to TAC or 3AC) is an intermediate code used by optimizing compilers to aid in the implementation of code-improving transformations. Each TAC instruction has at most three operands and is typically a combination of assignment and a binary operator. For example, t1 := t2 + t3. The name derives from the use of three operands in these statements even though instructions with fewer operands may occur. A refinement of three-address code is A-normal form (ANF).
rdf:langString
En informatique, le code à trois adresses (TAC ou 3AC) est un type de langage intermédiaire utilisé par les compilateurs comme Clang-LLVM.Chaque instruction TAC a au plus trois opérandes et est généralement une combinaison d'affectation et d'un opérateur binaire. Par exemple, t1: = t2 + t3. Le nom dérive de l'utilisation de trois opérandes dans ces instructions même si des instructions avec moins d'opérandes peuvent se produire.
rdf:langString
In informatica il Three Address Code (abbreviato in TAC o 3AC) è una forma di rappresentazione del codice intermedio utilizzata dai compilatori.Ogni istruzione nel 3AC può essere descritta dalla quadrupla (operatore, operando1, operando2, risultato) che rappresenta l'operazione dove x (risultato), y (operando1) e z (operando2) sono variabili (temporanee o meno) e gli operandi possono anche essere delle costanti. Il simbolo indica un generico operatore (ad esempio un operatore aritmetico). Le espressioni che contengono più di un'operazione fondamentale, come
rdf:langString
Em ciência da computação, o código de três endereços é uma forma de representar código intermediário usado por compiladores para auxiliar na implementação das transformações voltadas a melhorar o código. Um código de três endereços é uma representação linear de um Grafo acíclico dirigido (DAG). Cada instrução em um código de três endereços pode ser descrita como uma 4-tupla: (operador, operando1, operando2, resultado). Cada declaração tem a forma geral de: tal como: Expressões que contenham mais de uma operação fundamental, tais como:
rdf:langString
Three address code is een term uit de informatica waarmee een bepaald type van interne representaties voor compilers aangeduid wordt. In het algemeen bestaat three address code uit een reeks van statements met de vorm: x := y op z waarbij op een willekeurige operator is en x, y en z argumenten zijn die naar geheugenadressen, registers, constanten of labels verwijzen. Hoewel three address code ook statements met één of helemaal geen argumenten kan bevatten, of statements zonder resultaatstoewijzing (doel), zijn er nooit meer dan twee argumenten en één doel. Vandaar de naam three address code.
rdf:langString
rdf:langString
Tříadresní kód
rdf:langString
Código de tres direcciones
rdf:langString
Three address code
rdf:langString
Code à trois adresses
rdf:langString
3番地コード
rdf:langString
3-어드레스 코드
rdf:langString
Three address code
rdf:langString
Código de três endereços
rdf:langString
Three-address code
rdf:langString
三位址碼
xsd:integer
478945
xsd:integer
1089835936
rdf:langString
Tříadresní kód (často označovaný jako tříadresný kód nebo tříadresový kód) označuje v informatice formu mezijazyka, používanou překladačem jako pomůcku pro optimalizaci kódu. Každý příkaz v tříadresním kódu je zapsán pomocí uspořádané čtveřice: operátor, operand1, operand2 a výsledek.
rdf:langString
En ciencias de la computación, el código de tres direcciones (en inglés: three address code, normalmente abreviado a TAC o 3AC) es un lenguaje intermedio usado por compiladores optimizadores para ayudar en las transformaciones de mejora de código. Cada instrucción TAC tiene a lo sumo tres operandos y es típicamente una combinación de asignación y operador binario. Por ejemplo, t1 := t2 + t3. El nombre proviene del uso de tres operandos en estas declaraciones aunque instrucciones con menos operandos pueden existir. Ya que el código de tres direcciones es usado como un lenguaje intermedio en los compiladores, los operandos normalmente no contendrán direcciones de memoria o registros concretos, sino que direcciones simbólicas que serán convertidas en direcciones reales durante la asignación de registros. Es también común que los nombres de los operandos sean numerados secuencialmente ya que el código de tres direcciones es típicamente generado por el compilador.
rdf:langString
En informatique, le code à trois adresses (TAC ou 3AC) est un type de langage intermédiaire utilisé par les compilateurs comme Clang-LLVM.Chaque instruction TAC a au plus trois opérandes et est généralement une combinaison d'affectation et d'un opérateur binaire. Par exemple, t1: = t2 + t3. Le nom dérive de l'utilisation de trois opérandes dans ces instructions même si des instructions avec moins d'opérandes peuvent se produire. Étant donné que le code à trois adresses est utilisé comme langage intermédiaire dans les compilateurs, les opérandes ne seront probablement pas des adresses mémoire concrètes ou des registres de processeur, mais plutôt des adresses symboliques qui seront traduites en adresses réelles lors de l'allocation des registres. Il n'est pas rare non plus que les noms d'opérandes soient numérotés séquentiellement, car le code à trois adresses est généralement généré par le compilateur.
rdf:langString
In computer science, three-address code (often abbreviated to TAC or 3AC) is an intermediate code used by optimizing compilers to aid in the implementation of code-improving transformations. Each TAC instruction has at most three operands and is typically a combination of assignment and a binary operator. For example, t1 := t2 + t3. The name derives from the use of three operands in these statements even though instructions with fewer operands may occur. Since three-address code is used as an intermediate language within compilers, the operands will most likely not be concrete memory addresses or processor registers, but rather symbolic addresses that will be translated into actual addresses during register allocation. It is also not uncommon that operand names are numbered sequentially since three-address code is typically generated by the compiler. A refinement of three-address code is A-normal form (ANF).
rdf:langString
3-어드레스 코드(Three-address code)는 컴파일러에서 사용되는 중간 언어의 한 종류로, 컴파일러 최적화를 실현하는데 사용된다. '3-어드레스'로 불리는 것은 2개의 입력용과 1개의 출력용 메모리 주소 혹은 레지스터를 지정하는 형식이기 때문이다.
rdf:langString
3アドレスコード（英: three-address code）とは、コンピュータ・プログラミング言語処理系などにおける中間表現などにおける形式の1パターンである。処理系においては、コンパイラ最適化などの処理を掛けるのに適している。2つの入力と1つの出力のアドレス（メモリまたはレジスタ）を指定する形式であるため、3アドレスコードと呼ばれる。命令セットアーキテクチャにおける「3オペランド」形式の類推とも言える。
rdf:langString
In informatica il Three Address Code (abbreviato in TAC o 3AC) è una forma di rappresentazione del codice intermedio utilizzata dai compilatori.Ogni istruzione nel 3AC può essere descritta dalla quadrupla (operatore, operando1, operando2, risultato) che rappresenta l'operazione dove x (risultato), y (operando1) e z (operando2) sono variabili (temporanee o meno) e gli operandi possono anche essere delle costanti. Il simbolo indica un generico operatore (ad esempio un operatore aritmetico). Le espressioni che contengono più di un'operazione fondamentale, come non sono rappresentabili in 3AC come singola istruzione, ma vanno scomposte in una serie equivalente di operazioni fondamentali: Il termine Three Address Code viene utilizzato anche quando alcune operazioni utilizzano più (o meno) di due operandi. La caratteristica principale del 3AC è infatti che ogni istruzione implementa esattamente un'operazione fondamentale. Una versione più raffinata del 3AC è data dallo (SSA).
rdf:langString
Three address code is een term uit de informatica waarmee een bepaald type van interne representaties voor compilers aangeduid wordt. In het algemeen bestaat three address code uit een reeks van statements met de vorm: x := y op z waarbij op een willekeurige operator is en x, y en z argumenten zijn die naar geheugenadressen, registers, constanten of labels verwijzen. Hoewel three address code ook statements met één of helemaal geen argumenten kan bevatten, of statements zonder resultaatstoewijzing (doel), zijn er nooit meer dan twee argumenten en één doel. Vandaar de naam three address code. Three address code kan beschouwd worden als een assembly voor een virtuele machine met een oneindig aantal registers. Three address code lijkt vaak op assembly voor bestaande processoren en is daardoor voor een groot deel eenvoudig in machinetaal te vertalen. Het statement x := x + y * z kan in three address code als volgt weergegeven worden: t1 := x * zx := x + t1 waarbij t1 een door de compiler gegenereerde tijdelijke variabele (een register) is. Behalve rekenkundige bewerkingen en toewijzingen zijn er in het algemeen nog een aantal soorten statements in three address codes, waaronder voorwaardelijke en onvoorwaardelijke spronginstructies, procedure-aanroepen en ondersteuning voor arrays.
rdf:langString
Em ciência da computação, o código de três endereços é uma forma de representar código intermediário usado por compiladores para auxiliar na implementação das transformações voltadas a melhorar o código. Um código de três endereços é uma representação linear de um Grafo acíclico dirigido (DAG). Cada instrução em um código de três endereços pode ser descrita como uma 4-tupla: (operador, operando1, operando2, resultado). Cada declaração tem a forma geral de: tal como: onde x, y e z são variáveis, constantes ou variáveis temporárias geradas pelo compilador. op representa qualquer operador, por exemplo, um operador aritmético. Expressões que contenham mais de uma operação fundamental, tais como: não são representáveis em código de três endereços como uma única instrução. Em vez disso, elas são decompostas em uma série equivalente de instruções, tais como O termo código de três endereços é usado, mesmo que algumas instruções usem mais ou menos de dois operandos. As principais características do código de três endereços são de que cada instrução implementa exatamente uma operação fundamental, e que a origem e o destino pode se referir a qualquer registro disponível.
rdf:langString
三位址碼（英語：Three address code，經常被縮寫為TAC 或 3AC），一種中間語言，編譯器使用它來改進程式碼轉換效率。每個三位址碼指令，都可以被分解為一個四元組（4-tuple）：（運算子，運算元1，運算元2，結果）。因為每個陳述都包含了至多三個（如：goto语句，仅含一个变数）變數，所以它被稱為三位址碼。
xsd:nonNegativeInteger
3289