/************************************************************************* * Programme principal *************************************************************************/ int main(int argc, char *argv[]) { int end_Menu = 0; db_Used active_Db; memset(&active_Db, sizeof(active_Db), 0); while(!end_Menu) { switch(showMenu(active_Db)) { case SELECT_AGENDA: selectAgenda(&active_Db); break; case NEW_AGENDA: createAgenda(); break; case APPEND_ENTRY: newEntry(&active_Db); break; case IMPORT_ENTRIES: importEntries(&active_Db); break; case SEARCH_PART: searchPart(&active_Db); break; case SEARCH_NUM: searchNum(&active_Db); break; case READ_ALL: readAll(&active_Db); break; case QUIT: printf("Bye bye !\n\n"); end_Menu = 1; break; default: printf("Error !\nBad Entry, try again.\n\n"); break; } } return 0; }
void JSModuleRecord::instantiateDeclarations(ExecState* exec, ModuleProgramExecutable* moduleProgramExecutable) { VM& vm = exec->vm(); auto scope = DECLARE_THROW_SCOPE(vm); // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation SymbolTable* symbolTable = moduleProgramExecutable->moduleEnvironmentSymbolTable(); JSModuleEnvironment* moduleEnvironment = JSModuleEnvironment::create(vm, exec->lexicalGlobalObject(), exec->lexicalGlobalObject(), symbolTable, jsTDZValue(), this); // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation // section 15.2.1.16.4 step 9. // Ensure all the indirect exports are correctly resolved to unique bindings. // Even if we avoided duplicate exports in the parser, still ambiguous exports occur due to the star export (`export * from "mod"`). // When we see this type of ambiguity for the indirect exports here, throw a syntax error. for (const auto& pair : exportEntries()) { const ExportEntry& exportEntry = pair.value; if (exportEntry.type == JSModuleRecord::ExportEntry::Type::Indirect) { Resolution resolution = resolveExport(exec, exportEntry.exportName); switch (resolution.type) { case Resolution::Type::NotFound: throwSyntaxError(exec, scope, makeString("Indirectly exported binding name '", String(exportEntry.exportName.impl()), "' is not found.")); return; case Resolution::Type::Ambiguous: throwSyntaxError(exec, scope, makeString("Indirectly exported binding name '", String(exportEntry.exportName.impl()), "' cannot be resolved due to ambiguous multiple bindings.")); return; case Resolution::Type::Error: throwSyntaxError(exec, scope, makeString("Indirectly exported binding name 'default' cannot be resolved by star export entries.")); return; case Resolution::Type::Resolved: break; } } } // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation // section 15.2.1.16.4 step 12. // Instantiate namespace objects and initialize the bindings with them if required. // And ensure that all the imports correctly resolved to unique bindings. for (const auto& pair : importEntries()) { const ImportEntry& importEntry = pair.value; AbstractModuleRecord* importedModule = hostResolveImportedModule(exec, importEntry.moduleRequest); if (importEntry.isNamespace(vm)) { JSModuleNamespaceObject* namespaceObject = importedModule->getModuleNamespace(exec); RETURN_IF_EXCEPTION(scope, void()); bool putResult = false; symbolTablePutTouchWatchpointSet(moduleEnvironment, exec, importEntry.localName, namespaceObject, /* shouldThrowReadOnlyError */ false, /* ignoreReadOnlyErrors */ true, putResult); } else { Resolution resolution = importedModule->resolveExport(exec, importEntry.importName); switch (resolution.type) { case Resolution::Type::NotFound: throwSyntaxError(exec, scope, makeString("Importing binding name '", String(importEntry.importName.impl()), "' is not found.")); return; case Resolution::Type::Ambiguous: throwSyntaxError(exec, scope, makeString("Importing binding name '", String(importEntry.importName.impl()), "' cannot be resolved due to ambiguous multiple bindings.")); return; case Resolution::Type::Error: throwSyntaxError(exec, scope, makeString("Importing binding name 'default' cannot be resolved by star export entries.")); return; case Resolution::Type::Resolved: break; } } } // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation // section 15.2.1.16.4 step 14. // Module environment contains the heap allocated "var", "function", "let", "const", and "class". // When creating the environment, we initialized all the slots with empty, it's ok for lexical values. // But for "var" and "function", we should initialize it with undefined. They are contained in the declared variables. for (const auto& variable : declaredVariables()) { SymbolTableEntry entry = symbolTable->get(variable.key.get()); VarOffset offset = entry.varOffset(); if (!offset.isStack()) { bool putResult = false; symbolTablePutTouchWatchpointSet(moduleEnvironment, exec, Identifier::fromUid(exec, variable.key.get()), jsUndefined(), /* shouldThrowReadOnlyError */ false, /* ignoreReadOnlyErrors */ true, putResult); } } // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation // section 15.2.1.16.4 step 16-a-iv. // Initialize heap allocated function declarations. // They can be called before the body of the module is executed under circular dependencies. UnlinkedModuleProgramCodeBlock* unlinkedCodeBlock = moduleProgramExecutable->unlinkedModuleProgramCodeBlock(); for (size_t i = 0, numberOfFunctions = unlinkedCodeBlock->numberOfFunctionDecls(); i < numberOfFunctions; ++i) { UnlinkedFunctionExecutable* unlinkedFunctionExecutable = unlinkedCodeBlock->functionDecl(i); SymbolTableEntry entry = symbolTable->get(unlinkedFunctionExecutable->name().impl()); VarOffset offset = entry.varOffset(); if (!offset.isStack()) { ASSERT(!unlinkedFunctionExecutable->name().isEmpty()); if (vm.typeProfiler() || vm.controlFlowProfiler()) { vm.functionHasExecutedCache()->insertUnexecutedRange(moduleProgramExecutable->sourceID(), unlinkedFunctionExecutable->typeProfilingStartOffset(), unlinkedFunctionExecutable->typeProfilingEndOffset()); } JSFunction* function = JSFunction::create(vm, unlinkedFunctionExecutable->link(vm, moduleProgramExecutable->source()), moduleEnvironment); bool putResult = false; symbolTablePutTouchWatchpointSet(moduleEnvironment, exec, unlinkedFunctionExecutable->name(), function, /* shouldThrowReadOnlyError */ false, /* ignoreReadOnlyErrors */ true, putResult); } } m_moduleEnvironment.set(vm, this, moduleEnvironment); }