def main(): import getopt global verbose, recurse, dryrun, makebackup, nspaces try: opts, args = getopt.getopt( sys.argv[1:], "drnvNh", ["dryrun", "recurse", "nobackup", "verbose", "spaces", "help"]) except getopt.error(msg): usage(msg) return for o, a in opts: if o in ('-d', '--dryrun'): dryrun += 1 elif o in ('-r', '--recurse'): recurse += 1 elif o in ('-n', '--nobackup'): makebackup = False elif o in ('-v', '--verbose'): verbose += 1 elif o in ('-N', '--spaces'): nspaces = 4 elif o in ('-h', '--help'): usage() return if not args: r = Reindenter(sys.stdin) r.run() r.write(sys.stdout) return for arg in args: check(arg)
def main(): import getopt global verbose, recurse, dryrun, makebackup, nspaces try: opts, args = getopt.getopt(sys.argv[1:], "drnvNh", ["dryrun", "recurse", "nobackup", "verbose", "spaces", "help"]) except getopt.error(msg): usage(msg) return for o, a in opts: if o in ('-d', '--dryrun'): dryrun += 1 elif o in ('-r', '--recurse'): recurse += 1 elif o in ('-n', '--nobackup'): makebackup = False elif o in ('-v', '--verbose'): verbose += 1 elif o in ('-N', '--spaces'): nspaces = 4 elif o in ('-h', '--help'): usage() return if not args: r = Reindenter(sys.stdin) r.run() r.write(sys.stdout) return for arg in args: check(arg)
def main(): global mesPacked mesPacked = MesPacked() try: opts, args = getopt.getopt(sys.argv[1:], "") if len(args) > 2: raise getopt.error("Too many arguments.") except getopt.error as msg: usage(msg) for o, a in opts: pass if args: try: host = args[0] port = int(args[1]) except ValueError as msg: usage(msg) else: host = loadSettings(1, mesPacked) port = loadSettings(2, mesPacked) module = sys.argv[0].split('/')[-1].split('.')[0] sys_info = "Starting {0} from Python:{1}.{2}\n".format( module, sys.version_info.major, sys.version_info.minor) print(sys_info) main_thread(host, port)
def parseArgs(self, argv): global server import getopt try: options, args = getopt.getopt(argv[1:], 'hHvq', ['help','verbose','quiet']) for opt, value in options: if opt in ('-h','-H','--help'): self.usageExit() if opt in ('-q','--quiet'): self.verbosity = 0 if opt in ('-v','--verbose'): self.verbosity = 2 if len(args) == 0: raise getopt.error("You must provide a server name.") server = args[0] args = args[1:] if len(args) == 0 and self.defaultTest is None: self.test = self.testLoader.loadTestsFromModule(self.module) return if len(args) > 0: self.testNames = args else: self.testNames = (self.defaultTest,) self.createTests() except getopt.error, msg: self.usageExit(msg)
def parseArgs(self, argv): global server import getopt try: options, args = getopt.getopt(argv[1:], 'hHvq', ['help', 'verbose', 'quiet']) for opt, value in options: if opt in ('-h', '-H', '--help'): self.usageExit() if opt in ('-q', '--quiet'): self.verbosity = 0 if opt in ('-v', '--verbose'): self.verbosity = 2 if len(args) == 0: raise getopt.error("You must provide a server name.") server = args[0] args = args[1:] if len(args) == 0 and self.defaultTest is None: self.test = self.testLoader.loadTestsFromModule(self.module) return if len(args) > 0: self.testNames = args else: self.testNames = (self.defaultTest, ) self.createTests() except getopt.error, msg: self.usageExit(msg)
def main(): sys.stdout = sys.stderr try: opts, rest = getopt.getopt(sys.argv[1:], 'h:p:d:qvL') if not rest: cmd = 'head' else: cmd, rest = rest[0], rest[1:] if cmd not in commands: raise getopt.error("unknown command") coptset, func = commands[cmd] copts, files = getopt.getopt(rest, coptset) except getopt.error as msg: print(msg) print("usage: rrcs [options] command [options] [file] ...") print("where command can be:") print(" ci|put # checkin the given files") print(" co|get # checkout") print(" info # print header info") print(" head # print revision of head branch") print(" list # list filename if valid") print(" log # print full log") print(" diff # diff rcs file and work file") print("if no files are given, all remote rcs files are assumed") sys.exit(2) x = openrcsclient(opts) if not files: files = x.listfiles() for fn in files: try: func(x, copts, fn) except (IOError, os.error) as msg: print("%s: %s" % (fn, msg))
def main (): try: opts, args = getopt.getopt(sys.argv[1:], 'hVo:', ['help', 'version', 'output-file=']) except getopt.error(msg): usage(1, msg) outfile = None # parse options for opt, arg in opts: if opt in ('-h', '--help'): usage(0) elif opt in ('-V', '--version'): print >> sys.stderr, "msgfmt.py", __version__ sys.exit(0) elif opt in ('-o', '--output-file'): outfile = arg # do it if not args: print >> sys.stderr, 'No input file given' print >> sys.stderr, "Try `msgfmt --help' for more information." return for filename in args: make(filename, outfile)
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "shc", ["help", "train-spam", "train-ham", "check"]) if len(opts) == 0 or len(args) == 0: raise getopt.error("no options or argumens") except getopt.error, msg: print(msg) usage() sys.exit(2)
def main(): tabsize = 8 try: opts, args = getopt.getopt(sys.argv[1:], "t:") if not args: raise getopt.error("At least one file argument required") except getopt.error, msg: print msg print "usage:", sys.argv[0], "[-t tabwidth] file ..." return
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "h", ["help"]) except getopt.error(msg): print(msg) sys.exit(2) for arg in args: print("Compiling " + arg + "... ") print("=========") compile(arg) print("====") print("done.")
def main(): norun = False verbose = False check = False instlibdir = None reallibdir = None try: opts, args = getopt.getopt(sys.argv[1:], 'vncs:') for o, v in opts: if o == '-v': verbose = True if o == '-n': norun = True if o == '-c': check = True if o == '-s': if not ':' in v: raise getopt.error instlibdir, reallibdir = v.split(':') if len(args) != 1: raise getopt.error('missing arguments') except getopt.error: print 'Usage: %s [-vnc] [-s instlibdir:reallibdir] bundlepath ' % sys.argv[ 0] print 'Recursively slurp dylibs used in a bundle.' print '-n\tNo-run, only print actions, do not do the work' print '-v\tVerbose, print actions as well as doing them' print '-c\tCheck, do nothing, print nothing, return nonzero exit status if there was work' print '-s\tSet library directory substitution (for uninstalled libraries)' sys.exit(1) internalizer = Internalizer(os.path.realpath(args[0]), MACOSX_BUNDLE_DIRS) if norun: internalizer.norun = True internalizer.verbose = True elif verbose: internalizer.verbose = True elif check: internalizer.norun = True if instlibdir: internalizer.set_staging_libdir(instlibdir, reallibdir) internalizer.add_standard() internalizer.run() if internalizer.errors_encountered: print 'Errors encountered during internalization' sys.exit(1) if check: if internalizer.work_done: sys.exit(1)
def option_parse(args): socketType = port = listeners = packSize = None opts, args = getopt.getopt(args, "tup:l:s:", ["tcp", "udp" , "port=", "size=", "listeners="]) for o, v in opts: if o in ("-t", "--tcp") and socketType == None: socketType = socket.SOCK_STREAM elif o in ("-u", "--udp") and socketType == None: socketType = socket.SOCK_DGRAM elif o in ("-p", "--port") and v != "" and port == None: port = int(v) elif o in ("-l", "--listeners") and v != "" and listeners == None: listeners = int(v) elif o in ("-s", "--size") and v!= "" and packSize == None: packSize = int(v) else: raise getopt.error("ERROR in %s, %s option" % (o, v)) if socketType == None: raise getopt.error("SOCKET TYPE (-t or -u) is required") if port == None: port = DEFAULT_PORT if listeners == None: listeners = DEFAULT_LISTENER if packSize == None: packSize = DEFAULT_PACKSIZE return socketType, port, listeners, packSize
def main(): tabsize = 8 try: opts, args = getopt.getopt(sys.argv[1:], "t:") if not args: raise getopt.error("At least one file argument required") except getopt.error as msg: print(msg) print("usage:", sys.argv[0], "[-t tabwidth] file ...") return for optname, optvalue in opts: if optname == '-t': tabsize = int(optvalue) for filename in args: process(filename, tabsize)
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "") if len(args) > 1: raise getopt.error("Too many arguments.") except getopt.error as msg: usage(msg) for o, a in opts: pass if args: try: port = string.atoi(args[0]) except ValueError as msg: usage(msg) else: port = PORT main_thread(port)
def parse_args(argv): docs = 0 verbosity = 1 try: options, args = getopt.getopt(argv, "hH?vqd", ["help", "verbose", "quiet", "doc"]) if args: raise getopt.error("no arguments accepted, got %s" % list(args)) except getopt.error as err: usage_exit(err) for opt, value in options: if opt in ("-h", "-H", "-?", "--help"): usage_exit() if opt in ("-q", "--quit"): verbosity = 0 if opt in ("-v", "--verbose"): verbosity = 2 if opt in ("-d", "--doc"): docs = 1 verbosity = 2 return docs, verbosity
def parse_args(argv): docs = 0 verbosity = 1 try: options, args = getopt.getopt(argv, 'hH?vqd', ['help', 'verbose', 'quiet', 'doc']) if args: raise getopt.error('no arguments accepted, got %s' % list(args)) except getopt.error as err: usage_exit(err) for opt, value in options: if opt in ('-h','-H','-?','--help'): usage_exit() if opt in ('-q','--quit'): verbosity = 0 if opt in ('-v', '--verbose'): verbosity = 2 if opt in ('-d', '--doc'): docs = 1 verbosity = 2 return docs, verbosity
def parse_args(argv): docs = 0 verbosity = 1 try: options, args = getopt.getopt(argv, 'hH?vqd', ['help', 'verbose', 'quiet', 'doc']) if args: raise getopt.error('no arguments accepted, got %s' % list(args)) except getopt.error as err: usage_exit(err) for opt, value in options: if opt in ('-h', '-H', '-?', '--help'): usage_exit() if opt in ('-q', '--quit'): verbosity = 0 if opt in ('-v', '--verbose'): verbosity = 2 if opt in ('-d', '--doc'): docs = 1 verbosity = 2 return docs, verbosity
def loadParameters(): global socketClient try: opts, args = getopt.getopt(sys.argv[1:], "") if len(args) > 2: raise getopt.error("Too many arguments.") except getopt.error as msg: usage(msg) for o, a in opts: pass if args: try: host = args[0] port = int(args[1]) socketClient = SocketClient(host, port) return 0 except ValueError as msg: usage(msg) return -1 except IndexError: socketClient = SocketClient('localhost', 8889) else: socketClient = SocketClient()
def handleOptions(): # set defaults from reportlab import rl_config options = { 'cols': 2, 'handout': 0, 'printout': 0, 'help': 0, 'notes': 0, 'fx': 1, 'verbose': rl_config.verbose, 'silent': 0, 'outDir': None } args = sys.argv[1:] args = filter(lambda x: x and x[0] == '-', args) + filter( lambda x: not x or x[0] != '-', args) try: shortOpts = 'hnvsx' longOpts = 'cols= outdir= handout help notes printout verbose silent nofx'.split( ) optList, args = getopt.getopt(args, shortOpts, longOpts) except getopt.error(msg): options['help'] = 1 if not args and os.path.isfile('pythonpoint.xml'): args = ['pythonpoint.xml'] # Remove leading dashes (max. two). for i in range(len(optList)): o, v = optList[i] while o[0] == '-': o = o[1:] optList[i] = (o, v) if o == 'cols': options['cols'] = int(v) elif o == 'outdir': options['outDir'] = v if filter(lambda ov: ov[0] == 'handout', optList): options['handout'] = 1 if filter(lambda ov: ov[0] == 'printout', optList): options['printout'] = 1 if optList == [] and args == [] or \ filter(lambda ov: ov[0] in ('h', 'help'), optList): options['help'] = 1 if filter(lambda ov: ov[0] in ('n', 'notes'), optList): options['notes'] = 1 if filter(lambda ov: ov[0] in ('x', 'nofx'), optList): options['fx'] = 0 if filter(lambda ov: ov[0] in ('v', 'verbose'), optList): options['verbose'] = 1 #takes priority over verbose. Used by our test suite etc. #to ensure no output at all if filter(lambda ov: ov[0] in ('s', 'silent'), optList): options['silent'] = 1 options['verbose'] = 0 return options, args
for option, value in optlist: if option == "--help" or option == "-h": usage() sys.exit(0) elif option == "--number" or option == "-n": num = int(value) elif option == "--maxsize" or option == "-m": maxsize = int(value) elif option == "--percentrandom" or option == "-p": percent_random = float(value) elif option == "--tld" or option == "-t": tld = str(value) elif option == "--zonefile" or option == "-f": zone_file = str(value) else: getopt.error("Unknown option " + option) except getopt.error as reason: sys.stderr.write(sys.argv[0] + ": " + str(reason) + "\n") usage() sys.exit(1) if len(args) > 0: usage() sys.exit(1) gen = random.Random() if zone_file: file = open(zone_file) line = file.readline() while line: domain_line = domain_ns_re.match(line)
print ('</dd>') ldap.set_option(ldap.OPT_DEBUG_LEVEL,0) ldap._trace_level = 0 subschemasubentry_dn,schema = ldap.schema.urlfetch(sys.argv[-1],ldap.trace_level) if subschemasubentry_dn is None: print ('No sub schema sub entry found!') sys.exit(1) try: options,args=getopt.getopt(sys.argv[1:],'',['html']) except getopt.error(e): print ('Error: %s\nUsage: schema_oc_tree.py [--html] [LDAP URL]') print("----------\n") html_output = options and options[0][0]=='--html' oc_tree = schema.tree(ldap.schema.ObjectClass) at_tree = schema.tree(ldap.schema.AttributeType) #for k,v in oc_tree.items(): # print k,'->',v #for k,v in at_tree.items(): # print k,'->',v if html_output: print ("""<html>
from ps_parsers import * from gml import * from psx import * uid_start = 0 graph_cat = gml_graph() cluster_id = 0 xref_file = False base_address = 0 # parse command line options. try: opts, args = getopt.getopt(sys.argv[1:], "x:b:", ["xref=", "base="]) if not len(args): raise getopt.error("no args") except getopt.GetoptError: sys.stderr.write("usage: ps_graph_cat [-x <xrefs file> -b <base addr>] <file_1> [file_2] ...") sys.exit(1) for o, a in opts: if o in ("-x", "--xref"): xref_file = a if o in ("-b", "--base"): base_address = long(a, 16) for input_file in args: graph_parser = gml_graph(uid_start) try: graph_parser.parse_file(input_file) except psx, x: sys.stderr.write(x.__str__())
def get_opt( FLAG_SPEC: List[Tuple[str, str, bool, str, Any]], ALLOW_ACTIONS: List[str] ) -> Tuple[ List[Dict[str, Any]], Dict[str, Any] ]: try: short_opts = "".join( [t[FlagIdx.SHORT_OPT] + (":" if t[FlagIdx.HAS_ARG] else "") for t in FLAG_SPEC if t[FlagIdx.SHORT_OPT] is not None]) long_opts = [t[FlagIdx.LONG_OPT] \ + ("=" if t[FlagIdx.HAS_ARG] else "") for t in FLAG_SPEC if t[FlagIdx.LONG_OPT] is not None] opts, args = getopt.getopt(sys.argv[1:], short_opts, long_opts) kwargs = {} actions = [] for t in FLAG_SPEC: # action 不加入 kwargs if t[FlagIdx.LONG_OPT] in ALLOW_ACTIONS: continue elif t[FlagIdx.HAS_ARG] is False: # 不带参数的选项跳过,等后续再追加 continue elif t[FlagIdx.ARG_DEFAULT_VALUE] is None: # 要带参数的选项,如果默认参数为 None,则跳过 continue # 以长参数名为 key,写入 ARG_DEFAULT_VALUE 值 kwargs[ t[FlagIdx.LONG_OPT] ] = t[FlagIdx.ARG_DEFAULT_VALUE] for (opt, val) in opts: flag = opt.lstrip('-') is_long_opt = opt[:2] == '--' # print(f'[D]. opt={opt}, flag={flag}, val={val}') ok = -1 for i, t in enumerate(FLAG_SPEC): if (is_long_opt and t[FlagIdx.LONG_OPT] == flag)\ or (not is_long_opt and t[FlagIdx.SHORT_OPT] == flag): ok = i break # print(f'is_long_opt={is_long_opt}, FLAG_SPEC[{ok}]={FLAG_SPEC[ok]}') if ok >= 0 and ok < len(FLAG_SPEC): default_value = FLAG_SPEC[ok][FlagIdx.ARG_DEFAULT_VALUE] action = FLAG_SPEC[ok][FlagIdx.LONG_OPT] value = default_value if FLAG_SPEC[ok][FlagIdx.HAS_ARG] == True: # 需要带参数的,以 default_value 字段的类型转换紧跟着传入的值 if default_value is None: value = None if isinstance(default_value, int): value = int(val) elif isinstance(default_value, float): value = float(val) else: value = val # 后面不带参数,也可以使用默认值 if action in ALLOW_ACTIONS: actions.append({action: value}) else: kwargs[action] = value if kwargs.get('help') is not None: raise getopt.error('') # print(f'kwargs={kwargs}', file=sys.stderr) # print(f'actions={actions}', file=sys.stderr) return actions, kwargs except getopt.error: print(get_usage(FLAG_SPEC), file=sys.stderr) sys.exit(1)
lexerPrint = False syntaxerPrint = False semantyxerPrint = False arguments, values = getopt.getopt(argumentList, unixOptions, gnuOptions) for arg, val in arguments: if arg in ['-p', '--path']: path = val elif arg in ['-l', '--lexer']: lexerPrint = True elif arg in ['-s', '--syntaxer']: syntaxerPrint = True elif arg in ['-g', '--generator']: semantyxerPrint = True if not path: raise getopt.error('path is required! (-p path)') tokens = lexer(path)['tokens'] if lexerPrint: print 'TOKENS:' printTokens(tokens) syntaxer = Syntaxer(tokens) if syntaxerPrint: print 'AST:' syntaxer.root.view() if not syntaxer.error: Semantyxer(syntaxer.root) if semantyxerPrint: print 'ASM:'
def main(argv): try: (opts, args) = getopt.getopt(argv[1:], 'a:p:o:') nacl_build_subarch = 0 output_file = sys.stdout nacl_path = os.getcwd() for opt, val in opts: if opt == '-o': output_filename = val elif opt == '-a': if val.lower() == 'win32': nacl_build_subarch = 32 as_exe = as32 elif val.lower() == 'x64': nacl_build_subarch = 64 as_exe = as64 else: raise getopt.error('Unknown target architecture ' + val) # endif elif opt == '-p': nacl_path = (val) # endif # endfor if nacl_build_subarch == 0: raise getopt.error( 'You must specify a build architecture: ' + 'either -a Win32 or -a x64' ) # endif if not output_filename: raise getopt.error( 'No output file specified' ) # endif for filename in args: # normalize the filename to avoid any DOS-type funkiness filename = os.path.abspath(filename) filename = filename.replace('\\', '/') # # Run the C compiler as a preprocessor and pipe the output into a string # print >>sys.stderr, 'Preprocessing...' cl_env = os.environ.copy() cl_env['PATH'] = os.environ['PRE_WINPY_PATH'] p = subprocess.Popen(['cl.exe', '/DNACL_BLOCK_SHIFT=5' '/DNACL_BUILD_ARCH=' + str(nacl_build_subarch), '/DNACL_BUILD_SUBARCH=' + str(nacl_build_subarch), '/DNACL_WINDOWS=1', '/E', '/I' + nacl_path, filename], env=cl_env, shell=True, stdout=subprocess.PIPE) cl_output = p.communicate()[0] # # Uncomment this if you need to see exactly what the MSVC preprocessor # has done to your input file. #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT BEGINS #' #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, cl_output #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT ENDS #' #print >>sys.stderr, '-------------------------------------' # GNU uses '#<linenum> for line number directives; MSVC uses # '#line <linenum>.' foo = re.compile(r'^#line ', re.MULTILINE) cl_output = foo.sub(r'#', cl_output) if p.wait() == 0: # success # # Pipe the preprocessor output into the assembler # print >>sys.stderr, 'Assembling...' p = subprocess.Popen([nacl_path + as_exe, '-defsym','@feat.00=1', '--' + str(nacl_build_subarch), '-o', output_filename ], stdin=subprocess.PIPE, stderr=subprocess.PIPE) as_output, as_error = p.communicate(cl_output) # # massage the assembler stderr into a format that Visual Studio likes # as_error = re.sub(r'\{standard input\}', filename, as_error) as_error = re.sub(r':([0-9]+):', r'(\1) :', as_error) as_error = re.sub(r'Error', 'error', as_error) as_error = re.sub(r'Warning', 'warning', as_error) print >>sys.stderr, as_error # endif # endfor except getopt.error, e: print >>sys.stderr, str(e) print >>sys.std4err, ['Usage: ', argv[0], '-a {Win32|x64} -o output_file [-p native_client_path] input_file']
# write changes to disk if newLayer.SyncToDisk() != 0: print >>sys.stderr, 'Changes to layer "%s" could not be synced to disk' % (newLayer.GetName()) else: print >>sys.stdout, 'Changes to layer "%s" successfully synced to disk' % (newLayer.GetName()) # finshed with the datasources newShape = None oldShape = None if __name__ == "__main__": try: # no long arguments, too lazy to implement for now... opts, args = getopt.getopt(sys.argv[1:], "i:o:", []) options = [option[0] for option in opts] inputs = [input[1] for input in opts] required = set(["-i"]) if required.intersection(options) != required: raise getopt.error("Usage", "Missing required parameter") except getopt.GetoptError: Usage() sys.exit(2) # clean the file and save the output try: CleanShape(GetParam("-i", options, inputs), GetParam("-o", options, inputs, "clean")) except Exception as detail: print >>sys.stderr, "Exception: %s" % (str(detail))
# -*- coding: utf-8 -*- import sys, getopt sys.path.append('./lexical') sys.path.append('./syntaxer') sys.path.append('./code_generator') from lexical import lexical from syntaxer import syntaxer from code_generator import code_gen argument_list = sys.argv[1:] if not len(argument_list): raise getopt.error('path is required! (-h or --help)') for arg in argument_list: if arg in ['-l', '--lexer']: lexical('inputFile', True) elif arg in ['-s', '--syntaxer']: syntaxer(lexical('inputFile'), True) elif arg in ['-g', '--generator']: res = syntaxer(lexical('inputFile')) errors = res['errors'] parsed_tree = res['parsed_tree'] if not len(errors): code_gen(parsed_tree) elif arg in ['-h', '--help']: print " -l, --lexer start lexer \n -s, --syntaxer start syntax \n -h, --help show help "
def main(): norun = False verbose = False check = False debug = False trace = False debug = False trace = False instlibdir = None reallibdir = None if trace: print "%s: %s"%(sys._getframe().f_code.co_name,"begin") if trace: print "%s: %s"%(sys._getframe().f_code.co_name,"begin") try: opts, args = getopt.getopt(sys.argv[1:], 'vncdts:') for o, v in opts: if o == '-v': verbose = True if o == '-n': norun = True if o == '-c': check = True if o == '-d': debug = True if o == '-t': trace = True if o == '-s': if not ':' in v: raise getopt.error instlibdir, reallibdir = v.split(':') if len(args) != 1: raise getopt.error("Must specify bundlepath only.") except getopt.error: print 'Usage: %s [-vnc] [-s instlibdir:reallibdir] bundlepath '% sys.argv[0] print 'Recursively slurp dylibs used in a bundle.' print '-n\tNo-run, only print actions, do not do the work' print '-v\tVerbose, print actions as well as doing them' print '-c\tCheck, do nothing, print nothing, return nonzero exit status if there was work' print '-s\tSet library directory substitution (for uninstalled libraries)' print '-t\tTrace, print each function name and arguments when called ' print '-d\tDebug, print a lot of detailed information, e.g. to debug this script' sys.exit(1) internalizer = Internalizer(os.path.realpath(args[0]), LINUX_BUNDLE_DIRS) if norun: internalizer.norun = True internalizer.verbose = True elif verbose: internalizer.verbose = True elif check: internalizer.norun = True if debug: if verbose: internalizer.verbose = True internalizer.debug = True if debug: if verbose: internalizer.verbose = True internalizer.debug = True if trace: if verbose: internalizer.verbose = True internalizer.trace = True if trace: if verbose: internalizer.verbose = True internalizer.trace = True internalizer.add_standard() internalizer.run() if check: if internalizer.work_done: sys.exit(1)
try: value = inputs[options.index(optionName)] return value if value != '' else default except: return default if __name__ == '__main__': try: #no long arguments, too lazy to implement for now... opts, args = getopt.getopt(sys.argv[1:], "c:f:v:", []) options = [option[0] for option in opts] inputs = [input[1] for input in opts] required = set(['-c', '-f']) if required.intersection(options) != required: raise getopt.error('Usage', 'Missing required parameter') except getopt.GetoptError: Usage() sys.exit(2) #get the storage object storage = load(GetParam('-c', options, inputs)) #get the verbosity try: verbosity = int(GetParam('-v', options, inputs)) except: verbosity = None #for each line count = 0
def handle_option(self, opt, val): raise getopt.error("option %s not recognized" % opt)
'us' : USpaper, 'usr' : USRpaper } paperdef = A4Rpaper try: optlist, args = getopt.getopt(sys.argv[1:], "nkt:") for opt, arg in optlist: if opt == '-n': nodeflag = 1 if opt == '-k': knownflag = 1 if opt == '-t': if arg in papertypes: paperdef = papertypes[arg] else: raise getopt.error("unknown paper type '%s'" % arg) except getopt.error as msg: sys.stderr.write("%s: %s\n" % (__scriptname, msg)) printusage() sys.exit(1) if len(args) != 1: printusage() sys.exit(1) filename = args[0] profile = open(filename).readlines() # Build the call tree.
def main(args=None): prefs = grailbase.GrailPrefs.AllPreferences() # XXX Disable cache for NT if sys.platform == 'win32': prefs.Set('disk-cache', 'size', '0') global ilu_tk ilu_tk = 0 if prefs.GetBoolean('security', 'enable-ilu'): try: import ilu_tk except ImportError: pass if args is not None: embedded = 1 else: args = sys.argv[1:] embedded = 0 try: opts, args = getopt.getopt(args, 'd:g:iq', ['display=', 'geometry=', 'noimages']) if len(args) > 1: raise getopt.error("too many arguments") except getopt.error as msg: sys.stdout = sys.stderr print("Command line error:", msg) print(USAGE) sys.exit(2) geometry = prefs.Get('browser', 'initial-geometry') display = None user_init = 1 for o, a in opts: if o in ('-i', '--noimages'): load_images = 0 if o in ('-g', '--geometry'): geometry = a if o in ('-d', '--display'): display = a if o == "-q": user_init = 0 if args: url = grailutil.complete_url(args[0]) else: url = None global app app = Application(prefs=prefs, display=display) app.embedded = embedded if __name__ != '__main__': import __main__ __main__.app = app __main__.GRAILVERSION = GRAILVERSION def load_images_vis_prefs(app=app): app.load_images = app.prefs.GetBoolean('browser', 'load-images') try: app.load_images = load_images except NameError: load_images_vis_prefs() prefs.AddGroupCallback('browser', load_images_vis_prefs) from utils import Safetkinter Safetkinter._castrate(app.root.tk) tktools.install_keybindings(app.root) # Make everybody who's still using urllib.urlopen go through the cache urllib.urlopen = app.open_url_simple # Add $GRAILDIR/user/ to sys.path subdir = os.path.join(app.graildir, 'user') if subdir not in sys.path: sys.path.insert(0, subdir) # Import user's grail startup file, defined as # $GRAILDIR/user/grailrc.py if it exists. if user_init: try: from SampleGrailDir import grailrc except ImportError as e: # Only catch this if grailrc itself doesn't import, # otherwise propogate. if str.split(e.args[0])[-1] != "grailrc": raise except: app.exception_dialog('during import of startup file') # Load the initial page (command line argument or from preferences) if not embedded: from Browser import Browser browser = Browser(app.root, app, geometry=geometry) if url: browser.context.load(url) elif prefs.GetBoolean('browser', 'load-initial-page'): browser.home_command() if not embedded: # Give the user control app.go()
long_options = ["base =", "recursive ="] try: # Parsing argument arguments, values = getopt.getopt(argumentList, options, long_options) # Checking each argument with options for currentArgument, currentValue in arguments: if currentArgument in ("-b", "--base"): arg_dict["base_value"] = int(currentValue) elif currentArgument in ("-r", "--recursive"): arg_dict["recursive"] = int(currentValue) # Check rest of the arguments if len(values) < 4: raise getopt.error("Required arguments were not given correctly") arg_dict["method"] = values[0] arg_dict["input_file_name"] = values[1] arg_dict["encoding"] = values[2] arg_dict["output_file_name"] = values[3] # Call method with arguments passed as parameters if arg_dict["method"] == "encode": result = encode(file_name=arg_dict["input_file_name"], output_name=arg_dict["output_file_name"], encoding=arg_dict["encoding"], base_value=arg_dict["base_value"]) for i in range(arg_dict["recursive"] - 1): result = encode(file_name=arg_dict["output_file_name"], output_name=arg_dict["output_file_name"], encoding=arg_dict["encoding"],
if __name__ == '__main__': try: (opts, args) = getopt.getopt(sys.argv[1:], "htg") mode = "gui" for opt, arg in opts: if opt == '-t': mode = "text" elif opt == '-g': mode = "gui" elif opt == '-h': usage() sys.exit(0) if not args: raise getopt.error("no kickstart files given") for fileName in args: # # Populate the userchoices singleton. # fauxroot.FAUXROOT = [os.path.join(TEST_DIR, "good-config.1")] si = test_scriptedinstall.ScriptedInstallPreparser(fileName) (result, errors, warnings) = si.preParse() if result == test_scriptedinstall.Result.FAIL: print "result=", result print '\n'.join(errors) print '\n'.join(warnings) fauxroot.FAUXROOT = None continue
def main(argv): try: (opts, args) = getopt.getopt(argv[1:], 'a:p:o:') nacl_build_subarch = 0 nacl_path = os.getcwd() output_filename = None for opt, val in opts: if opt == '-o': output_filename = val elif opt == '-a': if val.lower() == 'win32': nacl_build_arch = 'x86' nacl_build_subarch = 32 as_exe = as32 elif val.lower() == 'x64': nacl_build_arch = 'x86' nacl_build_subarch = 64 as_exe = as64 else: raise getopt.error('Unknown target architecture ' + val) elif opt == '-p': nacl_path = (val) if nacl_build_subarch == 0: raise getopt.error( 'You must specify a build architecture: ' + 'either -a Win32 or -a x64' ) if output_filename is None: raise getopt.error( 'No output file specified' ) for filename in args: # normalize the filename to avoid any DOS-type funkiness filename = os.path.abspath(filename) filename = filename.replace('\\', '/') # # Run the C compiler as a preprocessor and pipe the output into a string # cl_command = ['cl.exe', '/nologo', '/D__ASSEMBLER__', '/DNACL_BUILD_ARCH=' + nacl_build_arch, '/DNACL_BUILD_SUBARCH=' + str(nacl_build_subarch), '/DNACL_WINDOWS=1', '/TP', '/E', '/I' + nacl_path, filename] p = subprocess.Popen(cl_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) cl_results = p.communicate() cl_status = p.returncode cl_output = cl_results[0] cl_errors = cl_results[1] if cl_status != 0: print( 'FAILED: %s\n%s\n' % (' '.join(cl_command), cl_errors), file=sys.stderr) return cl_status # # Uncomment this if you need to see exactly what the MSVC preprocessor # has done to your input file. #print('-------------------------------------', file=sys.stderr) #print('# PREPROCESSOR OUTPUT BEGINS #', file=sys.stderr) #print('-------------------------------------', file=sys.stderr) #print(cl_output, file=sys.stderr) #print('-------------------------------------', file=sys.stderr) #print('# PREPROCESSOR OUTPUT ENDS #', file=sys.stderr) #print('-------------------------------------', file=sys.stderr) # GNU uses '#<linenum> for line number directives; MSVC uses # '#line <linenum>.' foo = re.compile(br'^#line ', re.MULTILINE) cl_output = foo.sub(br'#', cl_output) # # Pipe the preprocessor output into the assembler # as_command = [nacl_path + as_exe, '-defsym','@feat.00=1', '--' + str(nacl_build_subarch), '-o', output_filename] p = subprocess.Popen(as_command, stdin=subprocess.PIPE, stderr=subprocess.PIPE) as_output, as_error = p.communicate(cl_output) as_status = p.returncode # # massage the assembler stderr into a format that Visual Studio likes # as_error = re.sub(br'\{standard input\}', filename, as_error) as_error = re.sub(br':([0-9]+):', r'(\1) :', as_error) as_error = re.sub(br'Error', 'error', as_error) as_error = re.sub(br'Warning', 'warning', as_error) if as_error: print(as_error, file=sys.stderr) if as_status != 0: print('FAILED: %s\n' % ' '.join(as_command), file=sys.stderr) return as_status except getopt.error as e: print(str(e), file=sys.stderr) print( 'Usage: ', argv[0], '-a {Win32|x64} -o output_file [-p native_client_path] input_file', file=sys.stderr)
def main(argv): try: (opts, args) = getopt.getopt(argv[1:], 'a:p:o:') nacl_build_subarch = 0 output_file = sys.stdout nacl_path = os.getcwd() for opt, val in opts: if opt == '-o': output_filename = val elif opt == '-a': if val.lower() == 'win32': nacl_build_subarch = 32 as_exe = as32 elif val.lower() == 'x64': nacl_build_subarch = 64 as_exe = as64 else: raise getopt.error('Unknown target architecture ' + val) # endif elif opt == '-p': nacl_path = (val) # endif # endfor if nacl_build_subarch == 0: raise getopt.error('You must specify a build architecture: ' + 'either -a Win32 or -a x64') # endif if not output_filename: raise getopt.error('No output file specified') # endif for filename in args: # normalize the filename to avoid any DOS-type funkiness filename = os.path.abspath(filename) filename = filename.replace('\\', '/') # # Run the C compiler as a preprocessor and pipe the output into a string # print >> sys.stderr, 'Preprocessing...' cl_env = os.environ.copy() cl_env['PATH'] = os.environ['PRE_WINPY_PATH'] p = subprocess.Popen([ 'cl.exe', '/DNACL_BLOCK_SHIFT=5' '/DNACL_BUILD_ARCH=' + str(nacl_build_subarch), '/DNACL_BUILD_SUBARCH=' + str(nacl_build_subarch), '/DNACL_WINDOWS=1', '/E', '/I' + nacl_path, filename ], env=cl_env, shell=True, stdout=subprocess.PIPE) cl_output = p.communicate()[0] # # Uncomment this if you need to see exactly what the MSVC preprocessor # has done to your input file. #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT BEGINS #' #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, cl_output #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT ENDS #' #print >>sys.stderr, '-------------------------------------' # GNU uses '#<linenum> for line number directives; MSVC uses # '#line <linenum>.' foo = re.compile(r'^#line ', re.MULTILINE) cl_output = foo.sub(r'#', cl_output) if p.wait() == 0: # success # # Pipe the preprocessor output into the assembler # print >> sys.stderr, 'Assembling...' p = subprocess.Popen([ nacl_path + as_exe, '-defsym', '@feat.00=1', '--' + str(nacl_build_subarch), '-o', output_filename ], stdin=subprocess.PIPE, stderr=subprocess.PIPE) as_output, as_error = p.communicate(cl_output) # # massage the assembler stderr into a format that Visual Studio likes # as_error = re.sub(r'\{standard input\}', filename, as_error) as_error = re.sub(r':([0-9]+):', r'(\1) :', as_error) as_error = re.sub(r'Error', 'error', as_error) as_error = re.sub(r'Warning', 'warning', as_error) print >> sys.stderr, as_error # endif # endfor except getopt.error, e: print >> sys.stderr, str(e) print >> sys.std4err, [ 'Usage: ', argv[0], '-a {Win32|x64} -o output_file [-p native_client_path] input_file' ]
def main(argv): try: (opts, args) = getopt.getopt(argv[1:], "a:p:o:") nacl_build_subarch = 0 nacl_path = os.getcwd() output_filename = None for opt, val in opts: if opt == "-o": output_filename = val elif opt == "-a": if val.lower() == "win32": nacl_build_arch = "x86" nacl_build_subarch = 32 as_exe = as32 elif val.lower() == "x64": nacl_build_arch = "x86" nacl_build_subarch = 64 as_exe = as64 else: raise getopt.error("Unknown target architecture " + val) # endif elif opt == "-p": nacl_path = val # endif # endfor if nacl_build_subarch == 0: raise getopt.error("You must specify a build architecture: " + "either -a Win32 or -a x64") # endif if output_filename is None: raise getopt.error("No output file specified") # endif for filename in args: # normalize the filename to avoid any DOS-type funkiness filename = os.path.abspath(filename) filename = filename.replace("\\", "/") # # Run the C compiler as a preprocessor and pipe the output into a string # p = subprocess.Popen( [ "cl.exe", "/nologo", "/D__ASSEMBLER__", "/DNACL_BUILD_ARCH=" + nacl_build_arch, "/DNACL_BUILD_SUBARCH=" + str(nacl_build_subarch), "/DNACL_WINDOWS=1", "/TP", "/E", "/I" + nacl_path, filename, ], shell=True, stdout=subprocess.PIPE, stderr=open(os.devnull, "w"), ) cl_output = p.communicate()[0] # # Uncomment this if you need to see exactly what the MSVC preprocessor # has done to your input file. # print >>sys.stderr, '-------------------------------------' # print >>sys.stderr, '# PREPROCESSOR OUTPUT BEGINS #' # print >>sys.stderr, '-------------------------------------' # print >>sys.stderr, cl_output # print >>sys.stderr, '-------------------------------------' # print >>sys.stderr, '# PREPROCESSOR OUTPUT ENDS #' # print >>sys.stderr, '-------------------------------------' # GNU uses '#<linenum> for line number directives; MSVC uses # '#line <linenum>.' foo = re.compile(r"^#line ", re.MULTILINE) cl_output = foo.sub(r"#", cl_output) if p.wait() == 0: # success # # Pipe the preprocessor output into the assembler # p = subprocess.Popen( [ nacl_path + as_exe, "-defsym", "@feat.00=1", "--" + str(nacl_build_subarch), "-o", output_filename, ], stdin=subprocess.PIPE, stderr=subprocess.PIPE, ) as_output, as_error = p.communicate(cl_output) # # massage the assembler stderr into a format that Visual Studio likes # as_error = re.sub(r"\{standard input\}", filename, as_error) as_error = re.sub(r":([0-9]+):", r"(\1) :", as_error) as_error = re.sub(r"Error", "error", as_error) as_error = re.sub(r"Warning", "warning", as_error) if as_error: print >>sys.stderr, as_error # endif # endfor except getopt.error, e: print >>sys.stderr, str(e) print >>sys.stderr, ["Usage: ", argv[0], "-a {Win32|x64} -o output_file [-p native_client_path] input_file"]
def main(argv): try: (opts, args) = getopt.getopt(argv[1:], 'a:p:o:') nacl_build_subarch = 0 nacl_path = os.getcwd() output_filename = None for opt, val in opts: if opt == '-o': output_filename = val elif opt == '-a': if val.lower() == 'win32': nacl_build_arch = 'x86' nacl_build_subarch = 32 as_exe = as32 elif val.lower() == 'x64': nacl_build_arch = 'x86' nacl_build_subarch = 64 as_exe = as64 else: raise getopt.error('Unknown target architecture ' + val) elif opt == '-p': nacl_path = (val) if nacl_build_subarch == 0: raise getopt.error( 'You must specify a build architecture: ' + 'either -a Win32 or -a x64' ) if output_filename is None: raise getopt.error( 'No output file specified' ) for filename in args: # normalize the filename to avoid any DOS-type funkiness filename = os.path.abspath(filename) filename = filename.replace('\\', '/') # # Run the C compiler as a preprocessor and pipe the output into a string # cl_command = ['cl.exe', '/nologo', '/D__ASSEMBLER__', '/DNACL_BUILD_ARCH=' + nacl_build_arch, '/DNACL_BUILD_SUBARCH=' + str(nacl_build_subarch), '/DNACL_WINDOWS=1', '/TP', '/E', '/I' + nacl_path, filename] p = subprocess.Popen(cl_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) cl_results = p.communicate() cl_status = p.returncode cl_output = cl_results[0] cl_errors = cl_results[1] if cl_status != 0: print >>sys.stderr, 'FAILED: %s\n%s\n' % (' '.join(cl_command), cl_errors) return cl_status # # Uncomment this if you need to see exactly what the MSVC preprocessor # has done to your input file. #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT BEGINS #' #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, cl_output #print >>sys.stderr, '-------------------------------------' #print >>sys.stderr, '# PREPROCESSOR OUTPUT ENDS #' #print >>sys.stderr, '-------------------------------------' # GNU uses '#<linenum> for line number directives; MSVC uses # '#line <linenum>.' foo = re.compile(r'^#line ', re.MULTILINE) cl_output = foo.sub(r'#', cl_output) # # Pipe the preprocessor output into the assembler # as_command = [nacl_path + as_exe, '-defsym','@feat.00=1', '--' + str(nacl_build_subarch), '-o', output_filename] p = subprocess.Popen(as_command, stdin=subprocess.PIPE, stderr=subprocess.PIPE) as_output, as_error = p.communicate(cl_output) as_status = p.returncode # # massage the assembler stderr into a format that Visual Studio likes # as_error = re.sub(r'\{standard input\}', filename, as_error) as_error = re.sub(r':([0-9]+):', r'(\1) :', as_error) as_error = re.sub(r'Error', 'error', as_error) as_error = re.sub(r'Warning', 'warning', as_error) if as_error: print >>sys.stderr, as_error if as_status != 0: print >>sys.stderr, 'FAILED: %s\n' % ' '.join(as_command) return as_status except getopt.error, e: print >>sys.stderr, str(e) print >>sys.stderr, ['Usage: ', argv[0], '-a {Win32|x64} -o output_file [-p native_client_path] input_file']
print " $ %s -c newiso.iso" % argv[0] print " My ISO v1.0: OK" # # init code # fill_fields() if __name__ == '__main__': try: opts, args = getopt.getopt(sys.argv[1:], "hvb:clz") if len(args) != 1: raise getopt.error("expecting ISO path") isoPath = args[0] modeFunction = None for opt, arg in opts: if opt == "-h": usage() sys.exit() elif opt == "-v": VERBOSE += 1 elif opt == "-b": _id_off, id_len, _ = fields[ID_FIELD] if len(arg) > id_len: raise getopt.error( "volume identifier must be <= %d characters" % id_len)
def handleOptions(): # set defaults from reportlab import rl_config options = {'cols':2, 'handout':0, 'printout':0, 'help':0, 'notes':0, 'fx':1, 'verbose':rl_config.verbose, 'silent':0, 'outDir': None} args = sys.argv[1:] args = filter(lambda x: x and x[0]=='-',args) + filter(lambda x: not x or x[0]!='-',args) try: shortOpts = 'hnvsx' longOpts = 'cols= outdir= handout help notes printout verbose silent nofx'.split() optList, args = getopt.getopt(args, shortOpts, longOpts) except getopt.error(msg): options['help'] = 1 if not args and os.path.isfile('pythonpoint.xml'): args = ['pythonpoint.xml'] # Remove leading dashes (max. two). for i in range(len(optList)): o, v = optList[i] while o[0] == '-': o = o[1:] optList[i] = (o, v) if o == 'cols': options['cols'] = int(v) elif o=='outdir': options['outDir'] = v if filter(lambda ov: ov[0] == 'handout', optList): options['handout'] = 1 if filter(lambda ov: ov[0] == 'printout', optList): options['printout'] = 1 if optList == [] and args == [] or \ filter(lambda ov: ov[0] in ('h', 'help'), optList): options['help'] = 1 if filter(lambda ov: ov[0] in ('n', 'notes'), optList): options['notes'] = 1 if filter(lambda ov: ov[0] in ('x', 'nofx'), optList): options['fx'] = 0 if filter(lambda ov: ov[0] in ('v', 'verbose'), optList): options['verbose'] = 1 #takes priority over verbose. Used by our test suite etc. #to ensure no output at all if filter(lambda ov: ov[0] in ('s', 'silent'), optList): options['silent'] = 1 options['verbose'] = 0 return options, args