This is an old revision of the document!
Dans le domaine informatique, le code de trois adresses (three address code) représente un code intermédiaire utilisé pour les compilateurs en tant que moyen d'écrire des instructions. Chaque instruction consiste en:
Comme il s'agit d'un code intermédiaire, les opérands ne représentent pas d'adresses de mémoire ou de registres, mais plutôt des adresses symboliques qui seront traduites plus tard.
/* Expression */ e = (a-2)+(a-5) /* Three Address Code */ t1 = a - 2 t2 = a - 5 t3 = t1 + t2 e = t3
grammar Alf; start : (statement SEMICOLON NEWLINE*)* #multilineProg | statement SEMICOLON #singlelineProg ; statement : declaration #declarationRule | expression #expressionRule | list_declaration #listRule | function_declaration #functionRule | attribution #attributionRule | function_call #functionCallRule ; declaration : type VARIABLE EQ expression #variableDeclaration | type VARIABLE EQ function_call #variableFunctionCall ; type : INT #typeInt | FLOAT #typeFloat | STRING #typeString ; value : INT_NUMBER #valueInt | FLOAT_NUMBER #valueFloat | STRING_TEXT #valueString | VARIABLE #valueVariable ; expression : left=expression op=MUL right=expression #expressionMultiply | left=expression op=DIV right=expression #expressionDivision | left=expression op=REM right=expression #expressionRem | left=expression op=ADD right=expression #expressionAddition | left=expression op=SUB right=expression #expressionSubtraction | LP expression RP #expressionParanthesis | value #expressionValue ; attribution : VARIABLE EQ expression #variableAttribution ; list_declaration : LIST VARIABLE EQ LSP values RSP #listDeclaration ; values : (value COMMA)* #listValues ; function_declaration: FUNCTION VARIABLE LP (parameter COMMA*)* RP LB (statement SEMICOLON)* return_function RB #functionContent ; parameter : declaration #functionParameter ; return_function : RETURN statement SEMICOLON #returnStatement | RETURN SEMICOLON #emptyReturn ; function_call : VARIABLE LP (value COMMA*)* RP #functionCall ; WS : (' ') -> skip; NEWLINE : ([\r\n]+) -> skip; FUNCTION : 'function'; VARIABLE : ('_'[a-zA-Z0-9]+); ADD : '+'; SUB : '-'; MUL : '*'; DIV : '/'; REM : '%'; INT : 'int'; FLOAT : 'float'; STRING : 'string'; LIST : 'list'; LP : '('; RP : ')'; EQ : '='; SEMICOLON : ';'; LSP : '['; RSP : ']'; COMMA : ','; LB : '{'; RB : '}'; RETURN : 'return'; INT_NUMBER : ([0-9]+); FLOAT_NUMBER : ([0-9]+'.'[0-9]+); STRING_TEXT : ('"'~["]+'"'|'\''~[']+'\''); ;
import { ASTNode } from "./index"; import symbol_tree from './index'; import { Expression, ValueNode, AttributionNode, FunctionCallNode } from './index'; var variable_id = 0; let results: string[] = []; function nextVar () { return 'var' + variable_id++; } function writeThreeAddressCode (node) { if (node.id === 'StatementsNode') { for (var statement of node.statements) { writeThreeAddressCode(statement); } } else if (node instanceof FunctionCallNode) { /**TODO: * generate the three address code for each parameter of the node.parameters array * write on the screen the three address code for each parameter * node.result will be nextVar() * write on the screen the three address code for function call */ } else if (node instanceof ValueNode) { // the result for a number is the number itself node.result = node.value; } else if (node instanceof AttributionNode) { /** TODO: * generate the three address code for node.value * write on the screen the three address code for an attribution*/ } else if (node instanceof Expression) { if (node.left !== undefined && node.right !== undefined) { writeThreeAddressCode (node.left); writeThreeAddressCode (node.right); // node.left.result is the result of node.left // node.right.result is the result of node.right /** TODO: * node.result will be nextVar() * write on the screen the three address code based on result, left result, right result and operator*/ } } } var ast = parser.parse (str); console.log (JSON.stringify(ast, null, 4)); writeThreeAddressCode(ast);
if (a == 0) { result = 'null'; } else { result = 'not null'; }
function power (base, exp) { return base ^ exp; } power (4/2, 5);